LTL  2.0.x
Classes | Enumerations | Functions
ltl::ltl Namespace Reference

Classes

class  LTLException
 Exception indicating problems with LTL. More...
 
class  IOException
 Exception indicating problems with ASCII I/O. More...
 
class  RangeException
 Exception for ltl::MArray<T ,N> range check errors. More...
 
class  FitsException
 Exception indicating problems with FITS I/O. More...
 
class  LinearAlgebraException
 Exception indicating problems within Linear Algebra. More...
 
class  SingularMatrixException
 Exception indicating a singular Matrix. More...
 
class  DivergenceException
 Exception indicating a divergent iterative algorithm. More...
 
struct  __ltl_type_name
 
struct  __ltl_type_name< char >
 
struct  __ltl_type_name< short >
 
struct  __ltl_type_name< int >
 
struct  __ltl_type_name< long >
 
struct  __ltl_type_name< unsigned char >
 
struct  __ltl_type_name< unsigned short >
 
struct  __ltl_type_name< unsigned int >
 
struct  __ltl_type_name< unsigned long >
 
struct  __ltl_type_name< float >
 
struct  __ltl_type_name< double >
 
struct  __ltl_type_name< long double >
 
struct  __ltl_type_name< std::complex< float > >
 
struct  __ltl_type_name< std::complex< double > >
 
struct  __ltl_type_name< std::complex< long double > >
 
class  FVector
 Vector whose length is known at compile time. More...
 
class  ListInitializer
 
class  ListInitializationSwitch
 
class  FVMemory
 Memory and data access interface for ltl::FVMemory. More...
 
class  FVMemory< T, N, 0 >
 
struct  fviter_end_tag
 
class  FVIterConst
 
class  FVIterConst< T, N, 0 >
 
class  FVIter
 
class  FVIter< T, N, 0 >
 
class  _et_fvector_parse_base
 Just to keep everything together in class browsers ... More...
 
class  FVExprBinopNode
 Binary operation node. More...
 
class  FVExprUnopNode
 Unary operation node. More...
 
class  FVExprLiteralNode
 Literal number. More...
 
class  FVExprNode
 The expression class itself. More...
 
struct  asFVExpr
 We need a trait class to deal with literals. More...
 
struct  asFVExpr< FVExprNode< T, N > >
 Already an expression template term. More...
 
struct  asFVExpr< FVector< T, N, S > >
 An array operand. More...
 
class  tNLoop
 Template loop: More...
 
class  tFVSplitLoop
 Wrapper to decide whether template loop is ok or simple C-loop does better. More...
 
class  tFVLoop
 
class  tFVSplitLoop< A, B, operation, N, true >
 Template loop unrolling. More...
 
class  tFVSplitLoop< A, B, operation, N, false >
 We exceed the limit for template loop unrolling: Simple for-loop. More...
 
class  tNLoop< A, B, operation, 0 >
 End of recursion. More...
 
class  tNSwap
 
class  tFVSplitSwap
 
class  tFVSwap
 
class  tFVSplitSwap< A, B, N, true >
 
class  tFVSplitSwap< A, B, N, false >
 
class  tNSwap< A, B, 0 >
 
struct  precision_trait
 
struct  precision_trait< int >
 
struct  precision_trait< unsigned int >
 
struct  precision_trait< long >
 
struct  precision_trait< unsigned long >
 
struct  precision_trait< float >
 
struct  precision_trait< double >
 
struct  precision_trait< long double >
 
struct  precision_trait< std::complex< float > >
 
struct  precision_trait< std::complex< double > >
 
struct  precision_trait< std::complex< long double > >
 
struct  promote_smallint
 
struct  promote_smallint< bool >
 
struct  promote_smallint< char >
 
struct  promote_smallint< unsigned char >
 
struct  promote_smallint< short int >
 
struct  promote_smallint< short unsigned int >
 
struct  promote_to
 
struct  promote_to< T1, T2, 0 >
 
struct  promotion_trait
 
struct  sumtype_trait
 
struct  sumtype_trait< char >
 
struct  sumtype_trait< short >
 
struct  sumtype_trait< int >
 
struct  sumtype_trait< long >
 
struct  sumtype_trait< unsigned char >
 
struct  sumtype_trait< unsigned short >
 
struct  sumtype_trait< unsigned int >
 
struct  sumtype_trait< unsigned long >
 
struct  sumtype_trait< float >
 
struct  sumtype_trait< double >
 
struct  sumtype_trait< long double >
 
struct  _et_applic_base
 This is just to keep everything together in class browsers. More...
 
class  tVBoolLoop
 
class  tVBoolSplitLoop
 
class  tNBoolLoop
 
class  FMatrix
 Matrix with dimensions known at compile time. More...
 
class  FMExprNode
 Now the expression class itself. More...
 
class  tVBoolSplitLoop< Expr, N, true >
 
class  tVBoolSplitLoop< Expr, N, false >
 
class  tNBoolLoop< Expr, 0 >
 
class  tVAccumLoop
 
class  tVAccumSplitLoop
 
class  tNAccumLoop
 Template loop. More...
 
class  tVAccumSplitLoop< Expr, N, true >
 Template loop unrolling. More...
 
class  tVAccumSplitLoop< Expr, N, false >
 We exceed the limit for template loop unrolling: Simple for-loop. More...
 
class  tNAccumLoop< Expr, 0 >
 End of recursion. More...
 
class  _assignfv_base
 Just to keep everything together in class browsers... More...
 
class  fv_equ_assign
 
class  fv_plu_assign
 
class  fv_min_assign
 
class  fv_mul_assign
 
class  fv_div_assign
 
class  fv_mod_assign
 
class  fv_xor_assign
 
class  fv_and_assign
 
class  fv_bor_assign
 
class  fv_sle_assign
 
class  fv_sri_assign
 
class  SynchronizedCounter
 
class  MemoryBlock
 
class  MemoryMapBlock
 
class  Range
 Class to enable referencing of ltl::MArray index ranges. More...
 
class  MArray
 A dynamic N-dimensional array storing objects of type T. More...
 
class  Shape
 
class  NoArgument
 
class  RangeSliceArgument
 
class  RangeSliceArgument< Range >
 
class  RangeSliceArgument< int >
 
class  RangeSliceArgument< NoArgument >
 
class  SliceCounter
 
class  FixedVector
 Vector with known length at compile time, 1-based, STL-compatible. More...
 
struct  ExprBase
 
struct  LTLIterator
 
class  MArrayIterConst
 
class  MArrayIter
 
class  ExprNode
 Node in the expression parse tree. Every expression in ultimately represented by this class. More...
 
class  ExprBinopNode
 Binary operation node in the expression parse tree. More...
 
class  ExprUnopNode
 Unary operation node in the expression parse tree. More...
 
class  ExprLiteralNode
 Node in the expression parse tree representing a literal number. More...
 
class  IndexIter
 
struct  cast
 
class  FMIterConst
 
class  FMIter
 
class  _et_fmatrix_parse_base
 Just to keep everything together in class browsers... More...
 
class  FMExprBinopNode
 Binary operation node. More...
 
class  FMExprUnopNode
 Unary operation node. More...
 
class  FMExprLiteralNode
 Literal number. More...
 
struct  asFMExpr
 We need a trait class to deal with literals. More...
 
struct  asFMExpr< FMExprNode< T, M, N > >
 Already an expression template term. More...
 
struct  asFMExpr< FMatrix< T, M, N > >
 An array operand. More...
 
class  tMNLoop
 
class  tFMSplitLoop
 
class  tFMLoop
 
class  tFMSplitLoop< A, B, operation, M, N, true >
 
class  tFMSplitLoop< A, B, operation, M, N, false >
 
class  tMNLoop< A, B, operation, N, I, 1 >
 
class  tMNLoop< A, B, operation, N, 1, 1 >
 
class  tMBoolLoop
 
class  tMBoolSplitLoop
 
class  tMNBoolLoop
 
class  tMBoolSplitLoop< Expr, M, N, true >
 
class  tMBoolSplitLoop< Expr, M, N, false >
 
class  tMNBoolLoop< Expr, N, I, 1 >
 
class  tMNBoolLoop< Expr, N, 1, 1 >
 
class  TMatTransposeFMExprOp
 Unary operation node for matrix transpose. More...
 
class  tMatVecLoop
 
class  tNMatVecLoop
 
class  tMatVecSplitLoop
 
class  TMatVecFVExprOp
 
class  tMatVecSplitLoop< A, B, T, N, true >
 
class  tMatVecSplitLoop< A, B, T, N, false >
 
class  tNMatVecLoop< A, B, T, N, 0 >
 
class  tMatMatLoop
 
class  tNMatMatLoop
 
class  tMatMatSplitLoop
 
class  TMatMatFMExprOp
 
class  tMatMatSplitLoop< A, B, T, N, true >
 
class  tMatMatSplitLoop< A, B, T, N, false >
 
class  tNMatMatLoop< A, B, T, N, 1 >
 
class  _assignfm_base
 
class  fm_equ_assign
 
class  fm_plu_assign
 
class  fm_min_assign
 
class  fm_mul_assign
 
class  fm_div_assign
 
class  fm_mod_assign
 
class  fm_xor_assign
 
class  fm_and_assign
 
class  fm_bor_assign
 
class  fm_sle_assign
 
class  fm_sri_assign
 
struct  tNMatPivot
 
class  tMatPivLoop
 
class  tMatPivSplitLoop
 
class  tNMatPivLoop
 
class  tMatElimLoop
 
class  tMatElimSplitLoop
 
class  tNMatElimLoop
 
class  tMatRestLoop
 
class  tMatRestSplitLoop
 
class  tNMatRestLoop
 
class  GaussJ
 Solve equation via Gauss-Jordan inversion or just do a Gauss-Jordan inversion. More...
 

Enumerations

enum  { minStart = INT_MIN, minEnd = INT_MIN }
 

Functions

template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TAdd
< T1, T2 >, N >, N > 
operator+ (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TAdd< T,
typename A::value_type >, N >
, N > 
operator+ (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TAdd
< typename A::value_type, T >
, N >, N > 
operator+ (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TAdd< typename
A::value_type, typename
B::value_type >, N >, N > 
operator+ (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TAdd< T, T >, N >, N > 
operator+ (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TAdd
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator+ (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TAdd
< T, T >, N >, N > 
operator+ (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TAdd< typename
T::value_type, typename
T::value_type >, N >, N > 
operator+ (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TSub
< T1, T2 >, N >, N > 
operator- (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TSub< T,
typename A::value_type >, N >
, N > 
operator- (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TSub
< typename A::value_type, T >
, N >, N > 
operator- (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TSub< typename
A::value_type, typename
B::value_type >, N >, N > 
operator- (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TSub< T, T >, N >, N > 
operator- (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TSub
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator- (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TSub
< T, T >, N >, N > 
operator- (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TSub< typename
T::value_type, typename
T::value_type >, N >, N > 
operator- (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TMul
< T1, T2 >, N >, N > 
operator* (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TMul< T,
typename A::value_type >, N >
, N > 
operator* (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TMul
< typename A::value_type, T >
, N >, N > 
operator* (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TMul< typename
A::value_type, typename
B::value_type >, N >, N > 
operator* (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TMul< T, T >, N >, N > 
operator* (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TMul
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator* (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TMul
< T, T >, N >, N > 
operator* (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TMul< typename
T::value_type, typename
T::value_type >, N >, N > 
operator* (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TDiv
< T1, T2 >, N >, N > 
operator/ (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TDiv< T,
typename A::value_type >, N >
, N > 
operator/ (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TDiv
< typename A::value_type, T >
, N >, N > 
operator/ (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TDiv< typename
A::value_type, typename
B::value_type >, N >, N > 
operator/ (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TDiv< T, T >, N >, N > 
operator/ (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TDiv
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator/ (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TDiv
< T, T >, N >, N > 
operator/ (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TDiv< typename
T::value_type, typename
T::value_type >, N >, N > 
operator/ (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TAnd
< T1, T2 >, N >, N > 
operator&& (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TAnd< T,
typename A::value_type >, N >
, N > 
operator&& (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TAnd
< typename A::value_type, T >
, N >, N > 
operator&& (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TAnd< typename
A::value_type, typename
B::value_type >, N >, N > 
operator&& (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TAnd< T, T >, N >, N > 
operator&& (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TAnd
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator&& (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TAnd
< T, T >, N >, N > 
operator&& (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TAnd< typename
T::value_type, typename
T::value_type >, N >, N > 
operator&& (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TOr
< T1, T2 >, N >, N > 
operator|| (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TOr< T,
typename A::value_type >, N >
, N > 
operator|| (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TOr
< typename A::value_type, T >
, N >, N > 
operator|| (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TOr< typename
A::value_type, typename
B::value_type >, N >, N > 
operator|| (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TOr< T, T >, N >, N > 
operator|| (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TOr
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator|| (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TOr< T,
T >, N >, N > 
operator|| (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TOr< typename
T::value_type, typename
T::value_type >, N >, N > 
operator|| (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator,
__ltl_TBitAnd< T1, T2 >, N >
, N > 
operator& (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TBitAnd< T,
typename A::value_type >, N >
, N > 
operator& (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator,
__ltl_TBitAnd< typename
A::value_type, T >, N >, N > 
operator& (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TBitAnd< typename
A::value_type, typename
B::value_type >, N >, N > 
operator& (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TBitAnd< T, T >, N >
, N > 
operator& (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TBitAnd
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator& (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator,
__ltl_TBitAnd< T, T >, N >, N > 
operator& (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TBitAnd< typename
T::value_type, typename
T::value_type >, N >, N > 
operator& (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TBitOr
< T1, T2 >, N >, N > 
operator| (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TBitOr< T,
typename A::value_type >, N >
, N > 
operator| (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TBitOr
< typename A::value_type, T >
, N >, N > 
operator| (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TBitOr< typename
A::value_type, typename
B::value_type >, N >, N > 
operator| (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TBitOr< T, T >, N >, N > 
operator| (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TBitOr
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator| (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TBitOr
< T, T >, N >, N > 
operator| (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TBitOr< typename
T::value_type, typename
T::value_type >, N >, N > 
operator| (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator,
__ltl_TBitXor< T1, T2 >, N >
, N > 
operator^ (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TBitXor< T,
typename A::value_type >, N >
, N > 
operator^ (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator,
__ltl_TBitXor< typename
A::value_type, T >, N >, N > 
operator^ (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TBitXor< typename
A::value_type, typename
B::value_type >, N >, N > 
operator^ (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TBitXor< T, T >, N >
, N > 
operator^ (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TBitXor
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator^ (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator,
__ltl_TBitXor< T, T >, N >, N > 
operator^ (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TBitXor< typename
T::value_type, typename
T::value_type >, N >, N > 
operator^ (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TMod
< T1, T2 >, N >, N > 
operator% (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TMod< T,
typename A::value_type >, N >
, N > 
operator% (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TMod
< typename A::value_type, T >
, N >, N > 
operator% (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TMod< typename
A::value_type, typename
B::value_type >, N >, N > 
operator% (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TMod< T, T >, N >, N > 
operator% (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TMod
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator% (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TMod
< T, T >, N >, N > 
operator% (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TMod< typename
T::value_type, typename
T::value_type >, N >, N > 
operator% (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TGT
< T1, T2 >, N >, N > 
operator> (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TGT< T,
typename A::value_type >, N >
, N > 
operator> (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TGT
< typename A::value_type, T >
, N >, N > 
operator> (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TGT< typename
A::value_type, typename
B::value_type >, N >, N > 
operator> (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TGT< T, T >, N >, N > 
operator> (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TGT
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator> (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TGT< T,
T >, N >, N > 
operator> (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TGT< typename
T::value_type, typename
T::value_type >, N >, N > 
operator> (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TLT
< T1, T2 >, N >, N > 
operator< (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TLT< T,
typename A::value_type >, N >
, N > 
operator< (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TLT
< typename A::value_type, T >
, N >, N > 
operator< (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TLT< typename
A::value_type, typename
B::value_type >, N >, N > 
operator< (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TLT< T, T >, N >, N > 
operator< (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TLT
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator< (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TLT< T,
T >, N >, N > 
operator< (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TLT< typename
T::value_type, typename
T::value_type >, N >, N > 
operator< (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TGE
< T1, T2 >, N >, N > 
operator>= (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TGE< T,
typename A::value_type >, N >
, N > 
operator>= (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TGE
< typename A::value_type, T >
, N >, N > 
operator>= (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TGE< typename
A::value_type, typename
B::value_type >, N >, N > 
operator>= (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TGE< T, T >, N >, N > 
operator>= (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TGE
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator>= (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TGE< T,
T >, N >, N > 
operator>= (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TGE< typename
T::value_type, typename
T::value_type >, N >, N > 
operator>= (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TLE
< T1, T2 >, N >, N > 
operator<= (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TLE< T,
typename A::value_type >, N >
, N > 
operator<= (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TLE
< typename A::value_type, T >
, N >, N > 
operator<= (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TLE< typename
A::value_type, typename
B::value_type >, N >, N > 
operator<= (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TLE< T, T >, N >, N > 
operator<= (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TLE
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator<= (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TLE< T,
T >, N >, N > 
operator<= (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TLE< typename
T::value_type, typename
T::value_type >, N >, N > 
operator<= (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TNE
< T1, T2 >, N >, N > 
operator!= (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TNE< T,
typename A::value_type >, N >
, N > 
operator!= (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TNE
< typename A::value_type, T >
, N >, N > 
operator!= (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TNE< typename
A::value_type, typename
B::value_type >, N >, N > 
operator!= (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TNE< T, T >, N >, N > 
operator!= (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TNE
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator!= (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TNE< T,
T >, N >, N > 
operator!= (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TNE< typename
T::value_type, typename
T::value_type >, N >, N > 
operator!= (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_TEQ
< T1, T2 >, N >, N > 
operator== (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_TEQ< T,
typename A::value_type >, N >
, N > 
operator== (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_TEQ
< typename A::value_type, T >
, N >, N > 
operator== (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_TEQ< typename
A::value_type, typename
B::value_type >, N >, N > 
operator== (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_TEQ< T, T >, N >, N > 
operator== (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_TEQ
< typename T::value_type,
typename T::value_type >, N >
, N > 
operator== (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_TEQ< T,
T >, N >, N > 
operator== (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_TEQ< typename
T::value_type, typename
T::value_type >, N >, N > 
operator== (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_TPlus
< T >, N >, N > 
operator+ (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_TPlus< typename
A::value_type >, N >, N > 
operator+ (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_TMinus
< T >, N >, N > 
operator- (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_TMinus< typename
A::value_type >, N >, N > 
operator- (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_TNot
< T >, N >, N > 
operator! (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_TNot< typename
A::value_type >, N >, N > 
operator! (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_TNeg
< T >, N >, N > 
operator~ (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_TNeg< typename
A::value_type >, N >, N > 
operator~ (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_sin< T >
, N >, N > 
sin (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_sin< typename
A::value_type >, N >, N > 
sin (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_cos< T >
, N >, N > 
cos (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_cos< typename
A::value_type >, N >, N > 
cos (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_tan< T >
, N >, N > 
tan (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_tan< typename
A::value_type >, N >, N > 
tan (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_asin
< T >, N >, N > 
asin (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_asin< typename
A::value_type >, N >, N > 
asin (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_acos
< T >, N >, N > 
acos (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_acos< typename
A::value_type >, N >, N > 
acos (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_atan
< T >, N >, N > 
atan (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_atan< typename
A::value_type >, N >, N > 
atan (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_sinh
< T >, N >, N > 
sinh (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_sinh< typename
A::value_type >, N >, N > 
sinh (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_cosh
< T >, N >, N > 
cosh (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_cosh< typename
A::value_type >, N >, N > 
cosh (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_tanh
< T >, N >, N > 
tanh (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_tanh< typename
A::value_type >, N >, N > 
tanh (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_exp< T >
, N >, N > 
exp (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_exp< typename
A::value_type >, N >, N > 
exp (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_log< T >
, N >, N > 
log (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_log< typename
A::value_type >, N >, N > 
log (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_log10
< T >, N >, N > 
log10 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_log10< typename
A::value_type >, N >, N > 
log10 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_sqrt
< T >, N >, N > 
sqrt (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_sqrt< typename
A::value_type >, N >, N > 
sqrt (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_fabs
< T >, N >, N > 
fabs (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_fabs< typename
A::value_type >, N >, N > 
fabs (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_floor
< T >, N >, N > 
floor (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_floor< typename
A::value_type >, N >, N > 
floor (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_ceil
< T >, N >, N > 
ceil (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_ceil< typename
A::value_type >, N >, N > 
ceil (const FVExprNode< A, N > &a)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_pow
< T1, T2 >, N >, N > 
pow (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_pow< T,
typename A::value_type >, N >
, N > 
pow (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_pow
< typename A::value_type, T >
, N >, N > 
pow (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_pow< typename
A::value_type, typename
B::value_type >, N >, N > 
pow (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_pow< T, T >, N >, N > 
pow (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_pow
< typename T::value_type,
typename T::value_type >, N >
, N > 
pow (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_pow< T,
T >, N >, N > 
pow (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_pow< typename
T::value_type, typename
T::value_type >, N >, N > 
pow (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_fmod
< T1, T2 >, N >, N > 
fmod (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_fmod< T,
typename A::value_type >, N >
, N > 
fmod (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_fmod
< typename A::value_type, T >
, N >, N > 
fmod (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_fmod< typename
A::value_type, typename
B::value_type >, N >, N > 
fmod (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_fmod< T, T >, N >, N > 
fmod (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_fmod
< typename T::value_type,
typename T::value_type >, N >
, N > 
fmod (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_fmod
< T, T >, N >, N > 
fmod (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_fmod< typename
T::value_type, typename
T::value_type >, N >, N > 
fmod (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_atan2
< T1, T2 >, N >, N > 
atan2 (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_atan2< T,
typename A::value_type >, N >
, N > 
atan2 (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_atan2
< typename A::value_type, T >
, N >, N > 
atan2 (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_atan2< typename
A::value_type, typename
B::value_type >, N >, N > 
atan2 (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_atan2< T, T >, N >, N > 
atan2 (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_atan2
< typename T::value_type,
typename T::value_type >, N >
, N > 
atan2 (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_atan2
< T, T >, N >, N > 
atan2 (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_atan2< typename
T::value_type, typename
T::value_type >, N >, N > 
atan2 (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_asinh
< T >, N >, N > 
asinh (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_asinh< typename
A::value_type >, N >, N > 
asinh (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_acosh
< T >, N >, N > 
acosh (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_acosh< typename
A::value_type >, N >, N > 
acosh (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_atanh
< T >, N >, N > 
atanh (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_atanh< typename
A::value_type >, N >, N > 
atanh (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_cbrt
< T >, N >, N > 
cbrt (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_cbrt< typename
A::value_type >, N >, N > 
cbrt (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_expm1
< T >, N >, N > 
expm1 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_expm1< typename
A::value_type >, N >, N > 
expm1 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_log1p
< T >, N >, N > 
log1p (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_log1p< typename
A::value_type >, N >, N > 
log1p (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_erf< T >
, N >, N > 
erf (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_erf< typename
A::value_type >, N >, N > 
erf (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_erfc
< T >, N >, N > 
erfc (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_erfc< typename
A::value_type >, N >, N > 
erfc (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_lgamma
< T >, N >, N > 
lgamma (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_lgamma< typename
A::value_type >, N >, N > 
lgamma (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_rint
< T >, N >, N > 
rint (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_rint< typename
A::value_type >, N >, N > 
rint (const FVExprNode< A, N > &a)
 
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode
< typename FVector< T1, N, S1 >
::const_iterator, typename
FVector< T2, N, S2 >
::const_iterator, __ltl_hypot
< T1, T2 >, N >, N > 
hypot (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator, FVExprNode
< A, N >, __ltl_hypot< T,
typename A::value_type >, N >
, N > 
hypot (const FVector< T, N, S > &a, const FVExprNode< A, N > &b)
 
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >, typename
FVector< T, N, S >
::const_iterator, __ltl_hypot
< typename A::value_type, T >
, N >, N > 
hypot (const FVExprNode< A, N > &a, const FVector< T, N, S > &b)
 
template<class A , class B , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< A, N >
, FVExprNode< B, N >
, __ltl_hypot< typename
A::value_type, typename
B::value_type >, N >, N > 
hypot (const FVExprNode< A, N > &a, const FVExprNode< B, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< typename FVector< T, N, S >
::const_iterator,
FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, __ltl_hypot< T, T >, N >, N > 
hypot (const FVector< T, N, S > &a, const typename FVector< T, N, S >::value_type &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprNode< T, N >
, FVExprLiteralNode< typename
T::value_type >, __ltl_hypot
< typename T::value_type,
typename T::value_type >, N >
, N > 
hypot (const FVExprNode< T, N > &a, const typename T::value_type &b)
 
template<class T , int N, int S>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
FVector< T, N, S >::value_type >
, typename FVector< T, N, S >
::const_iterator, __ltl_hypot
< T, T >, N >, N > 
hypot (const typename FVector< T, N, S >::value_type &a, const FVector< T, N, S > &b)
 
template<class T , int N>
FVExprNode< FVExprBinopNode
< FVExprLiteralNode< typename
T::value_type >, FVExprNode< T,
N >, __ltl_hypot< typename
T::value_type, typename
T::value_type >, N >, N > 
hypot (const typename T::value_type &a, const FVExprNode< T, N > &b)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow2
< T >, N >, N > 
pow2 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow2< typename
A::value_type >, N >, N > 
pow2 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow3
< T >, N >, N > 
pow3 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow3< typename
A::value_type >, N >, N > 
pow3 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow4
< T >, N >, N > 
pow4 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow4< typename
A::value_type >, N >, N > 
pow4 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow5
< T >, N >, N > 
pow5 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow5< typename
A::value_type >, N >, N > 
pow5 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow6
< T >, N >, N > 
pow6 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow6< typename
A::value_type >, N >, N > 
pow6 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow7
< T >, N >, N > 
pow7 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow7< typename
A::value_type >, N >, N > 
pow7 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_pow8
< T >, N >, N > 
pow8 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_pow8< typename
A::value_type >, N >, N > 
pow8 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_abs< T >
, N >, N > 
abs (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_abs< typename
A::value_type >, N >, N > 
abs (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_arg< T >
, N >, N > 
arg (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_arg< typename
A::value_type >, N >, N > 
arg (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_norm
< T >, N >, N > 
norm (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_norm< typename
A::value_type >, N >, N > 
norm (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_real
< T >, N >, N > 
real (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_real< typename
A::value_type >, N >, N > 
real (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_imag
< T >, N >, N > 
imag (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_imag< typename
A::value_type >, N >, N > 
imag (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode
< typename FVector< T, N, S >
::const_iterator, __ltl_conj
< T >, N >, N > 
conj (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode
< FVExprNode< A, N >
, __ltl_conj< typename
A::value_type >, N >, N > 
conj (const FVExprNode< A, N > &a)
 
template<class Expr , int N>
bool anyof (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
bool anyof (FVector< T, N, S > &e)
 
template<class Expr , int N>
bool allof (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
bool allof (FVector< T, N, S > &e)
 
template<class Expr , int N>
bool noneof (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
bool noneof (FVector< T, N, S > &e)
 
template<class T1 , class T2 , int N, int S1, int S2>
sumtype_trait< typename
promotion_trait< T1, T2 >
::PType >::SumType 
dot (const FVector< T1, N, S1 > &a, const FVector< T2, N, S2 > &b)
 
template<class T1 , class T2 , int N, int S1>
sumtype_trait< typename
promotion_trait< T1, T2 >
::PType >::SumType 
dot (const FVector< T1, N, S1 > &a, const FVExprNode< T2, N > &b)
 
template<class T1 , class T2 , int N, int S2>
sumtype_trait< typename
promotion_trait< T1, T2 >
::PType >::SumType 
dot (FVExprNode< T1, N > a, const FVector< T2, N, S2 > &b)
 
template<class T1 , class T2 , int N>
sumtype_trait< typename
promotion_trait< T1, T2 >
::PType >::SumType 
dot (const FVExprNode< T1, N > &a, const FVExprNode< T2, N > &b)
 
template<class Expr , int N>
sumtype_trait< typename
Expr::value_type >::SumType 
sum (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
sumtype_trait< T >::SumType sum (const FVector< T, N, S > &e)
 
template<class Expr , int N>
sumtype_trait< typename
Expr::value_type >::SumType 
sum2 (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
sumtype_trait< T >::SumType sum2 (const FVector< T, N, S > &e)
 
template<class Expr , int N>
sumtype_trait< typename
Expr::value_type >::SumType 
product (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
sumtype_trait< T >::SumType product (const FVector< T, N, S > &e)
 
template<int N>
std::istream & operator>> (std::istream &is, Shape< N > &s)
 
template<int N>
std::ostream & operator<< (std::ostream &os, const Shape< N > &s)
 
template<class T , int N>
std::ostream & operator<< (std::ostream &os, const FixedVector< T, N > &x)
 
template<typename A , typename B >
const Shape< A::dims > * _expr_getshape (const A &a, const B &)
 Determine the shape of an expression by returning the ltl::Shape objects on one of the ltl::MArray operatnds. More...
 
template<typename A , typename T >
const Shape< A::dims > * _expr_getshape (const A &a, const ExprLiteralNode< T > &)
 
template<typename A , typename T >
const Shape< A::dims > * _expr_getshape (const ExprLiteralNode< T > &, const A &a)
 
template<typename A , typename B >
int _expr_getalign (const A &a, const B &)
 Determine the alignment (w.r.t. natural vector boundaries) of the operands in an expression. More...
 
template<typename A , typename T >
int _expr_getalign (const A &a, const ExprLiteralNode< T > &)
 
template<typename T , typename A >
int _expr_getalign (const ExprLiteralNode< T > &, const A &a)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TAdd< T1, T2 >, N >, N > 
operator+ (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TAdd< T1, typename
T2::value_type >, N >, N > 
operator+ (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TAdd< typename
T1::value_type, T2 >, N >, N > 
operator+ (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TAdd< T1, T2 >, N >, N > 
operator+ (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TAdd
< T1, T2 >, N >, N > 
operator+ (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TAdd
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator+ (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TAdd< typename
T1::value_type, T2 >, N >, N > 
operator+ (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TAdd< T1, typename
T2::value_type >, N >, N > 
operator+ (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TSub< T1, T2 >, N >, N > 
operator- (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TSub< T1, typename
T2::value_type >, N >, N > 
operator- (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TSub< typename
T1::value_type, T2 >, N >, N > 
operator- (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TSub< T1, T2 >, N >, N > 
operator- (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TSub
< T1, T2 >, N >, N > 
operator- (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TSub
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator- (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TSub< typename
T1::value_type, T2 >, N >, N > 
operator- (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TSub< T1, typename
T2::value_type >, N >, N > 
operator- (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TMul< T1, T2 >, N >, N > 
operator* (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TMul< T1, typename
T2::value_type >, N >, N > 
operator* (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TMul< typename
T1::value_type, T2 >, N >, N > 
operator* (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TMul< T1, T2 >, N >, N > 
operator* (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TMul
< T1, T2 >, N >, N > 
operator* (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TMul
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator* (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TMul< typename
T1::value_type, T2 >, N >, N > 
operator* (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TMul< T1, typename
T2::value_type >, N >, N > 
operator* (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TDiv< T1, T2 >, N >, N > 
operator/ (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TDiv< T1, typename
T2::value_type >, N >, N > 
operator/ (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TDiv< typename
T1::value_type, T2 >, N >, N > 
operator/ (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TDiv< T1, T2 >, N >, N > 
operator/ (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TDiv
< T1, T2 >, N >, N > 
operator/ (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TDiv
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator/ (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TDiv< typename
T1::value_type, T2 >, N >, N > 
operator/ (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TDiv< T1, typename
T2::value_type >, N >, N > 
operator/ (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TAnd< T1, T2 >, N >, N > 
operator&& (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TAnd< T1, typename
T2::value_type >, N >, N > 
operator&& (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TAnd< typename
T1::value_type, T2 >, N >, N > 
operator&& (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TAnd< T1, T2 >, N >, N > 
operator&& (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TAnd
< T1, T2 >, N >, N > 
operator&& (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TAnd
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator&& (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TAnd< typename
T1::value_type, T2 >, N >, N > 
operator&& (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TAnd< T1, typename
T2::value_type >, N >, N > 
operator&& (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TOr< T1, T2 >, N >, N > 
operator|| (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TOr< T1, typename
T2::value_type >, N >, N > 
operator|| (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TOr< typename
T1::value_type, T2 >, N >, N > 
operator|| (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TOr< T1, T2 >, N >, N > 
operator|| (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TOr< T1,
T2 >, N >, N > 
operator|| (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TOr< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator|| (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TOr< typename
T1::value_type, T2 >, N >, N > 
operator|| (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TOr
< T1, typename T2::value_type >
, N >, N > 
operator|| (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TBitAnd< T1, T2 >, N >
, N > 
operator& (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TBitAnd< T1,
typename T2::value_type >, N >
, N > 
operator& (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TBitAnd< typename
T1::value_type, T2 >, N >, N > 
operator& (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TBitAnd< T1, T2 >, N >
, N > 
operator& (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TBitAnd
< T1, T2 >, N >, N > 
operator& (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TBitAnd
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator& (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TBitAnd< typename
T1::value_type, T2 >, N >, N > 
operator& (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TBitAnd< T1, typename
T2::value_type >, N >, N > 
operator& (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TBitOr< T1, T2 >, N >, N > 
operator| (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TBitOr< T1,
typename T2::value_type >, N >
, N > 
operator| (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TBitOr< typename
T1::value_type, T2 >, N >, N > 
operator| (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TBitOr< T1, T2 >, N >
, N > 
operator| (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TBitOr
< T1, T2 >, N >, N > 
operator| (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TBitOr
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator| (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TBitOr< typename
T1::value_type, T2 >, N >, N > 
operator| (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TBitOr< T1, typename
T2::value_type >, N >, N > 
operator| (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TBitXor< T1, T2 >, N >
, N > 
operator^ (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TBitXor< T1,
typename T2::value_type >, N >
, N > 
operator^ (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TBitXor< typename
T1::value_type, T2 >, N >, N > 
operator^ (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TBitXor< T1, T2 >, N >
, N > 
operator^ (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TBitXor
< T1, T2 >, N >, N > 
operator^ (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TBitXor
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator^ (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TBitXor< typename
T1::value_type, T2 >, N >, N > 
operator^ (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TBitXor< T1, typename
T2::value_type >, N >, N > 
operator^ (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TMod< T1, T2 >, N >, N > 
operator% (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TMod< T1, typename
T2::value_type >, N >, N > 
operator% (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TMod< typename
T1::value_type, T2 >, N >, N > 
operator% (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TMod< T1, T2 >, N >, N > 
operator% (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TMod
< T1, T2 >, N >, N > 
operator% (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TMod
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
operator% (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TMod< typename
T1::value_type, T2 >, N >, N > 
operator% (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_TMod< T1, typename
T2::value_type >, N >, N > 
operator% (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TGT< T1, T2 >, N >, N > 
operator> (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TGT< T1, typename
T2::value_type >, N >, N > 
operator> (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TGT< typename
T1::value_type, T2 >, N >, N > 
operator> (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TGT< T1, T2 >, N >, N > 
operator> (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TGT< T1,
T2 >, N >, N > 
operator> (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TGT< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator> (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TGT< typename
T1::value_type, T2 >, N >, N > 
operator> (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TGT
< T1, typename T2::value_type >
, N >, N > 
operator> (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TLT< T1, T2 >, N >, N > 
operator< (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TLT< T1, typename
T2::value_type >, N >, N > 
operator< (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TLT< typename
T1::value_type, T2 >, N >, N > 
operator< (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TLT< T1, T2 >, N >, N > 
operator< (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TLT< T1,
T2 >, N >, N > 
operator< (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TLT< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator< (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TLT< typename
T1::value_type, T2 >, N >, N > 
operator< (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TLT
< T1, typename T2::value_type >
, N >, N > 
operator< (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TGE< T1, T2 >, N >, N > 
operator>= (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TGE< T1, typename
T2::value_type >, N >, N > 
operator>= (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TGE< typename
T1::value_type, T2 >, N >, N > 
operator>= (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TGE< T1, T2 >, N >, N > 
operator>= (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TGE< T1,
T2 >, N >, N > 
operator>= (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TGE< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator>= (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TGE< typename
T1::value_type, T2 >, N >, N > 
operator>= (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TGE
< T1, typename T2::value_type >
, N >, N > 
operator>= (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TLE< T1, T2 >, N >, N > 
operator<= (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TLE< T1, typename
T2::value_type >, N >, N > 
operator<= (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TLE< typename
T1::value_type, T2 >, N >, N > 
operator<= (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TLE< T1, T2 >, N >, N > 
operator<= (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TLE< T1,
T2 >, N >, N > 
operator<= (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TLE< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator<= (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TLE< typename
T1::value_type, T2 >, N >, N > 
operator<= (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TLE
< T1, typename T2::value_type >
, N >, N > 
operator<= (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TNE< T1, T2 >, N >, N > 
operator!= (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TNE< T1, typename
T2::value_type >, N >, N > 
operator!= (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TNE< typename
T1::value_type, T2 >, N >, N > 
operator!= (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TNE< T1, T2 >, N >, N > 
operator!= (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TNE< T1,
T2 >, N >, N > 
operator!= (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TNE< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator!= (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TNE< typename
T1::value_type, T2 >, N >, N > 
operator!= (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TNE
< T1, typename T2::value_type >
, N >, N > 
operator!= (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_TEQ< T1, T2 >, N >, N > 
operator== (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_TEQ< T1, typename
T2::value_type >, N >, N > 
operator== (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_TEQ< typename
T1::value_type, T2 >, N >, N > 
operator== (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_TEQ< T1, T2 >, N >, N > 
operator== (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_TEQ< T1,
T2 >, N >, N > 
operator== (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_TEQ< typename
T1::value_type, typename
T2::value_type >, N >, N > 
operator== (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_TEQ< typename
T1::value_type, T2 >, N >, N > 
operator== (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_TEQ
< T1, typename T2::value_type >
, N >, N > 
operator== (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_TPlus
< typename T::value_type >, N >
, N > 
operator+ (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_TMinus
< typename T::value_type >, N >
, N > 
operator- (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_TNot
< typename T::value_type >, N >
, N > 
operator! (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_TNeg
< typename T::value_type >, N >
, N > 
operator~ (const ExprBase< T, N > &a)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_feq< T1, T2 >, N >, N > 
feq (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_feq< T1, typename
T2::value_type >, N >, N > 
feq (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_feq< typename
T1::value_type, T2 >, N >, N > 
feq (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_feq< T1, T2 >, N >, N > 
feq (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_feq< T1,
T2 >, N >, N > 
feq (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_feq< typename
T1::value_type, typename
T2::value_type >, N >, N > 
feq (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_feq< typename
T1::value_type, T2 >, N >, N > 
feq (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_feq
< T1, typename T2::value_type >
, N >, N > 
feq (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_fneq< T1, T2 >, N >, N > 
fneq (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_fneq< T1, typename
T2::value_type >, N >, N > 
fneq (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_fneq< typename
T1::value_type, T2 >, N >, N > 
fneq (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_fneq< T1, T2 >, N >, N > 
fneq (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_fneq
< T1, T2 >, N >, N > 
fneq (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_fneq
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
fneq (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_fneq< typename
T1::value_type, T2 >, N >, N > 
fneq (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_fneq< T1, typename
T2::value_type >, N >, N > 
fneq (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_sin
< typename T::value_type >, N >
, N > 
sin (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_cos
< typename T::value_type >, N >
, N > 
cos (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_tan
< typename T::value_type >, N >
, N > 
tan (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_asin
< typename T::value_type >, N >
, N > 
asin (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_acos
< typename T::value_type >, N >
, N > 
acos (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_atan
< typename T::value_type >, N >
, N > 
atan (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_sinh
< typename T::value_type >, N >
, N > 
sinh (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_cosh
< typename T::value_type >, N >
, N > 
cosh (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_tanh
< typename T::value_type >, N >
, N > 
tanh (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_exp
< typename T::value_type >, N >
, N > 
exp (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_log
< typename T::value_type >, N >
, N > 
log (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_log10
< typename T::value_type >, N >
, N > 
log10 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_sqrt
< typename T::value_type >, N >
, N > 
sqrt (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_fabs
< typename T::value_type >, N >
, N > 
fabs (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_floor
< typename T::value_type >, N >
, N > 
floor (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_ceil
< typename T::value_type >, N >
, N > 
ceil (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_round
< typename T::value_type >, N >
, N > 
round (const ExprBase< T, N > &a)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_pow< T1, T2 >, N >, N > 
pow (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_pow< T1, typename
T2::value_type >, N >, N > 
pow (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_pow< typename
T1::value_type, T2 >, N >, N > 
pow (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_pow< T1, T2 >, N >, N > 
pow (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_pow< T1,
T2 >, N >, N > 
pow (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_pow< typename
T1::value_type, typename
T2::value_type >, N >, N > 
pow (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_pow< typename
T1::value_type, T2 >, N >, N > 
pow (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >, __ltl_pow
< T1, typename T2::value_type >
, N >, N > 
pow (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_fmod< T1, T2 >, N >, N > 
fmod (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_fmod< T1, typename
T2::value_type >, N >, N > 
fmod (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_fmod< typename
T1::value_type, T2 >, N >, N > 
fmod (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_fmod< T1, T2 >, N >, N > 
fmod (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_fmod
< T1, T2 >, N >, N > 
fmod (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_fmod
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
fmod (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_fmod< typename
T1::value_type, T2 >, N >, N > 
fmod (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_fmod< T1, typename
T2::value_type >, N >, N > 
fmod (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_atan2< T1, T2 >, N >, N > 
atan2 (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_atan2< T1, typename
T2::value_type >, N >, N > 
atan2 (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_atan2< typename
T1::value_type, T2 >, N >, N > 
atan2 (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_atan2< T1, T2 >, N >
, N > 
atan2 (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_atan2
< T1, T2 >, N >, N > 
atan2 (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_atan2
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
atan2 (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_atan2< typename
T1::value_type, T2 >, N >, N > 
atan2 (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_atan2< T1, typename
T2::value_type >, N >, N > 
atan2 (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_asinh
< typename T::value_type >, N >
, N > 
asinh (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_acosh
< typename T::value_type >, N >
, N > 
acosh (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_atanh
< typename T::value_type >, N >
, N > 
atanh (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_cbrt
< typename T::value_type >, N >
, N > 
cbrt (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_expm1
< typename T::value_type >, N >
, N > 
expm1 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_log1p
< typename T::value_type >, N >
, N > 
log1p (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_erf
< typename T::value_type >, N >
, N > 
erf (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_erfc
< typename T::value_type >, N >
, N > 
erfc (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_lgamma
< typename T::value_type >, N >
, N > 
lgamma (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_rint
< typename T::value_type >, N >
, N > 
rint (const ExprBase< T, N > &a)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, typename
MArray< T2, N >::ConstIterator,
__ltl_hypot< T1, T2 >, N >, N > 
hypot (const MArray< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator, ExprNode< T2,
N >, __ltl_hypot< T1, typename
T2::value_type >, N >, N > 
hypot (const MArray< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, typename
MArray< T2, N >::ConstIterator,
__ltl_hypot< typename
T1::value_type, T2 >, N >, N > 
hypot (const ExprNode< T1, N > &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< typename MArray< T1, N >
::ConstIterator,
ExprLiteralNode< T2 >
, __ltl_hypot< T1, T2 >, N >
, N > 
hypot (const MArray< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, typename MArray< T2, N >
::ConstIterator, __ltl_hypot
< T1, T2 >, N >, N > 
hypot (const T1 &a, const MArray< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >, ExprNode
< T2, N >, __ltl_hypot
< typename T1::value_type,
typename T2::value_type >, N >
, N > 
hypot (const ExprNode< T1, N > &a, const ExprNode< T2, N > &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprNode< T1, N >
, ExprLiteralNode< T2 >
, __ltl_hypot< typename
T1::value_type, T2 >, N >, N > 
hypot (const ExprNode< T1, N > &a, const T2 &b)
 
template<typename T1 , typename T2 , int N>
ExprNode< ExprBinopNode
< ExprLiteralNode< T1 >
, ExprNode< T2, N >
, __ltl_hypot< T1, typename
T2::value_type >, N >, N > 
hypot (const T1 &a, const ExprNode< T2, N > &b)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_fpclassify
< typename T::value_type >, N >
, N > 
fpclassify (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_isfinite
< typename T::value_type >, N >
, N > 
isfinite (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_isinf
< typename T::value_type >, N >
, N > 
isinf (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_isnan
< typename T::value_type >, N >
, N > 
isnan (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_isnormal
< typename T::value_type >, N >
, N > 
isnormal (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow2
< typename T::value_type >, N >
, N > 
pow2 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow3
< typename T::value_type >, N >
, N > 
pow3 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow4
< typename T::value_type >, N >
, N > 
pow4 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow5
< typename T::value_type >, N >
, N > 
pow5 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow6
< typename T::value_type >, N >
, N > 
pow6 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow7
< typename T::value_type >, N >
, N > 
pow7 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_pow8
< typename T::value_type >, N >
, N > 
pow8 (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_abs
< typename T::value_type >, N >
, N > 
abs (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_arg
< typename T::value_type >, N >
, N > 
arg (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_norm
< typename T::value_type >, N >
, N > 
norm (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_real
< typename T::value_type >, N >
, N > 
real (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_imag
< typename T::value_type >, N >
, N > 
imag (const ExprBase< T, N > &a)
 
template<typename T , int N>
ExprNode< ExprUnopNode
< typename ExprNodeType< T >
::expr_type, __ltl_conj
< typename T::value_type >, N >
, N > 
conj (const ExprBase< T, N > &a)
 
template<class T , int N, class E >
void eval_assign_expr (MArray< T, N > &a, ExprNode< E, N > &e)
 
template<class T , int N, class E >
void eval_assign_expr_1 (MArray< T, N > &a, ExprNode< E, N > &e)
 We are dealing with the 1 dimensional scalar case here. More...
 
template<class T , int N, class E >
void eval_assign_expr_N (MArray< T, N > &a, ExprNode< E, N > &e)
 this handles the N-dimensional case More...
 
template<class T , int N, class E >
void eval_with_index_iter (MArray< T, N > &a, ExprNode< E, N > &e)
 
template<typename T , int N, typename Expr >
void eval_with_convolution (MArray< T, N > &, ExprNode< Expr, N > &)
 
template<typename T , typename Expr >
void eval_with_convolution (MArray< T, 1 > &A, ExprNode< Expr, 1 > &E)
 
template<typename T , typename Expr >
void eval_with_convolution (MArray< T, 2 > &A, ExprNode< Expr, 2 > &E)
 
template<typename T , typename Expr >
void eval_with_convolution (MArray< T, 3 > &A, ExprNode< Expr, 3 > &E)
 
template<typename T1 , int N>
ExprNode< IndexIterDimExpr< T1,
int, N >, N > 
indexPosInt (const MArray< T1, N > &a, const int dim)
 
template<typename T1 , int N>
ExprNode< IndexIterDimExpr< T1,
float, N >, N > 
indexPosFlt (const MArray< T1, N > &a, const int dim)
 
template<typename T1 , int N>
ExprNode< IndexIterDimExpr< T1,
double, N >, N > 
indexPosDbl (const MArray< T1, N > &a, const int dim)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TAdd
< T1, T2 >, M, N >, M, N > 
operator+ (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TAdd< T,
typename A::value_type >, M, N >
, M, N > 
operator+ (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TAdd
< typename A::value_type, T >
, M, N >, M, N > 
operator+ (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TAdd< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator+ (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TAdd< T, T >, M, N >
, M, N > 
operator+ (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TAdd
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator+ (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TAdd
< T, T >, M, N >, M, N > 
operator+ (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TAdd< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator+ (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TSub
< T1, T2 >, M, N >, M, N > 
operator- (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TSub< T,
typename A::value_type >, M, N >
, M, N > 
operator- (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TSub
< typename A::value_type, T >
, M, N >, M, N > 
operator- (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TSub< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator- (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TSub< T, T >, M, N >
, M, N > 
operator- (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TSub
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator- (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TSub
< T, T >, M, N >, M, N > 
operator- (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TSub< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator- (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TMul
< T1, T2 >, M, N >, M, N > 
operator* (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TMul< T,
typename A::value_type >, M, N >
, M, N > 
operator* (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TMul
< typename A::value_type, T >
, M, N >, M, N > 
operator* (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TMul< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator* (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TMul< T, T >, M, N >
, M, N > 
operator* (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TMul
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator* (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TMul
< T, T >, M, N >, M, N > 
operator* (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TMul< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator* (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TDiv
< T1, T2 >, M, N >, M, N > 
operator/ (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TDiv< T,
typename A::value_type >, M, N >
, M, N > 
operator/ (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TDiv
< typename A::value_type, T >
, M, N >, M, N > 
operator/ (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TDiv< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator/ (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TDiv< T, T >, M, N >
, M, N > 
operator/ (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TDiv
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator/ (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TDiv
< T, T >, M, N >, M, N > 
operator/ (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TDiv< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator/ (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TAnd
< T1, T2 >, M, N >, M, N > 
operator&& (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TAnd< T,
typename A::value_type >, M, N >
, M, N > 
operator&& (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TAnd
< typename A::value_type, T >
, M, N >, M, N > 
operator&& (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TAnd< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator&& (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TAnd< T, T >, M, N >
, M, N > 
operator&& (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TAnd
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator&& (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TAnd
< T, T >, M, N >, M, N > 
operator&& (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TAnd< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator&& (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TOr
< T1, T2 >, M, N >, M, N > 
operator|| (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TOr< T,
typename A::value_type >, M, N >
, M, N > 
operator|| (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TOr
< typename A::value_type, T >
, M, N >, M, N > 
operator|| (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TOr< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator|| (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TOr< T, T >, M, N >, M,
N > 
operator|| (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TOr
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator|| (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TOr< T,
T >, M, N >, M, N > 
operator|| (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TOr< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator|| (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator,
__ltl_TBitAnd< T1, T2 >, M, N >
, M, N > 
operator& (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TBitAnd< T,
typename A::value_type >, M, N >
, M, N > 
operator& (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator,
__ltl_TBitAnd< typename
A::value_type, T >, M, N >, M,
N > 
operator& (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TBitAnd< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator& (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TBitAnd< T, T >, M, N >
, M, N > 
operator& (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TBitAnd
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator& (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator,
__ltl_TBitAnd< T, T >, M, N >
, M, N > 
operator& (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TBitAnd
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator& (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TBitOr
< T1, T2 >, M, N >, M, N > 
operator| (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TBitOr< T,
typename A::value_type >, M, N >
, M, N > 
operator| (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TBitOr
< typename A::value_type, T >
, M, N >, M, N > 
operator| (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TBitOr< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator| (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TBitOr< T, T >, M, N >
, M, N > 
operator| (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TBitOr
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator| (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TBitOr
< T, T >, M, N >, M, N > 
operator| (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TBitOr< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator| (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator,
__ltl_TBitXor< T1, T2 >, M, N >
, M, N > 
operator^ (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TBitXor< T,
typename A::value_type >, M, N >
, M, N > 
operator^ (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator,
__ltl_TBitXor< typename
A::value_type, T >, M, N >, M,
N > 
operator^ (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TBitXor< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator^ (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TBitXor< T, T >, M, N >
, M, N > 
operator^ (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TBitXor
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator^ (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator,
__ltl_TBitXor< T, T >, M, N >
, M, N > 
operator^ (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TBitXor
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator^ (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TMod
< T1, T2 >, M, N >, M, N > 
operator% (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TMod< T,
typename A::value_type >, M, N >
, M, N > 
operator% (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TMod
< typename A::value_type, T >
, M, N >, M, N > 
operator% (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TMod< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator% (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TMod< T, T >, M, N >
, M, N > 
operator% (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TMod
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator% (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TMod
< T, T >, M, N >, M, N > 
operator% (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TMod< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator% (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TGT
< T1, T2 >, M, N >, M, N > 
operator> (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TGT< T,
typename A::value_type >, M, N >
, M, N > 
operator> (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TGT
< typename A::value_type, T >
, M, N >, M, N > 
operator> (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TGT< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator> (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TGT< T, T >, M, N >, M,
N > 
operator> (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TGT
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator> (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TGT< T,
T >, M, N >, M, N > 
operator> (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TGT< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator> (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TLT
< T1, T2 >, M, N >, M, N > 
operator< (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TLT< T,
typename A::value_type >, M, N >
, M, N > 
operator< (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TLT
< typename A::value_type, T >
, M, N >, M, N > 
operator< (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TLT< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator< (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TLT< T, T >, M, N >, M,
N > 
operator< (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TLT
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator< (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TLT< T,
T >, M, N >, M, N > 
operator< (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TLT< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator< (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TGE
< T1, T2 >, M, N >, M, N > 
operator>= (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TGE< T,
typename A::value_type >, M, N >
, M, N > 
operator>= (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TGE
< typename A::value_type, T >
, M, N >, M, N > 
operator>= (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TGE< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator>= (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TGE< T, T >, M, N >, M,
N > 
operator>= (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TGE
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator>= (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TGE< T,
T >, M, N >, M, N > 
operator>= (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TGE< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator>= (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TLE
< T1, T2 >, M, N >, M, N > 
operator<= (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TLE< T,
typename A::value_type >, M, N >
, M, N > 
operator<= (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TLE
< typename A::value_type, T >
, M, N >, M, N > 
operator<= (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TLE< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator<= (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TLE< T, T >, M, N >, M,
N > 
operator<= (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TLE
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator<= (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TLE< T,
T >, M, N >, M, N > 
operator<= (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TLE< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator<= (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TNE
< T1, T2 >, M, N >, M, N > 
operator!= (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TNE< T,
typename A::value_type >, M, N >
, M, N > 
operator!= (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TNE
< typename A::value_type, T >
, M, N >, M, N > 
operator!= (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TNE< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator!= (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TNE< T, T >, M, N >, M,
N > 
operator!= (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TNE
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator!= (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TNE< T,
T >, M, N >, M, N > 
operator!= (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TNE< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator!= (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_TEQ
< T1, T2 >, M, N >, M, N > 
operator== (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_TEQ< T,
typename A::value_type >, M, N >
, M, N > 
operator== (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TEQ
< typename A::value_type, T >
, M, N >, M, N > 
operator== (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_TEQ< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
operator== (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_TEQ< T, T >, M, N >, M,
N > 
operator== (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_TEQ
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
operator== (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_TEQ< T,
T >, M, N >, M, N > 
operator== (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_TEQ< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
operator== (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_TPlus
< T >, M, N >, M, N > 
operator+ (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_TPlus< typename
A::value_type >, M, N >, M, N > 
operator+ (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_TMinus
< T >, M, N >, M, N > 
operator- (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_TMinus< typename
A::value_type >, M, N >, M, N > 
operator- (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_TNot
< T >, M, N >, M, N > 
operator! (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_TNot< typename
A::value_type >, M, N >, M, N > 
operator! (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_TNeg
< T >, M, N >, M, N > 
operator~ (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_TNeg< typename
A::value_type >, M, N >, M, N > 
operator~ (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_sin< T >
, M, N >, M, N > 
sin (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_sin< typename
A::value_type >, M, N >, M, N > 
sin (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_cos< T >
, M, N >, M, N > 
cos (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_cos< typename
A::value_type >, M, N >, M, N > 
cos (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_tan< T >
, M, N >, M, N > 
tan (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_tan< typename
A::value_type >, M, N >, M, N > 
tan (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_asin
< T >, M, N >, M, N > 
asin (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_asin< typename
A::value_type >, M, N >, M, N > 
asin (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_acos
< T >, M, N >, M, N > 
acos (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_acos< typename
A::value_type >, M, N >, M, N > 
acos (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_atan
< T >, M, N >, M, N > 
atan (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_atan< typename
A::value_type >, M, N >, M, N > 
atan (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_sinh
< T >, M, N >, M, N > 
sinh (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_sinh< typename
A::value_type >, M, N >, M, N > 
sinh (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_cosh
< T >, M, N >, M, N > 
cosh (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_cosh< typename
A::value_type >, M, N >, M, N > 
cosh (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_tanh
< T >, M, N >, M, N > 
tanh (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_tanh< typename
A::value_type >, M, N >, M, N > 
tanh (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_exp< T >
, M, N >, M, N > 
exp (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_exp< typename
A::value_type >, M, N >, M, N > 
exp (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_log< T >
, M, N >, M, N > 
log (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_log< typename
A::value_type >, M, N >, M, N > 
log (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_log10
< T >, M, N >, M, N > 
log10 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_log10< typename
A::value_type >, M, N >, M, N > 
log10 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_sqrt
< T >, M, N >, M, N > 
sqrt (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_sqrt< typename
A::value_type >, M, N >, M, N > 
sqrt (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_fabs
< T >, M, N >, M, N > 
fabs (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_fabs< typename
A::value_type >, M, N >, M, N > 
fabs (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_floor
< T >, M, N >, M, N > 
floor (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_floor< typename
A::value_type >, M, N >, M, N > 
floor (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_ceil
< T >, M, N >, M, N > 
ceil (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_ceil< typename
A::value_type >, M, N >, M, N > 
ceil (const FMExprNode< A, M, N > &a)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_pow
< T1, T2 >, M, N >, M, N > 
pow (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_pow< T,
typename A::value_type >, M, N >
, M, N > 
pow (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_pow
< typename A::value_type, T >
, M, N >, M, N > 
pow (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_pow< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
pow (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_pow< T, T >, M, N >, M,
N > 
pow (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_pow
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
pow (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_pow< T,
T >, M, N >, M, N > 
pow (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_pow< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
pow (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_fmod
< T1, T2 >, M, N >, M, N > 
fmod (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_fmod< T,
typename A::value_type >, M, N >
, M, N > 
fmod (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_fmod
< typename A::value_type, T >
, M, N >, M, N > 
fmod (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_fmod< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
fmod (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_fmod< T, T >, M, N >
, M, N > 
fmod (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_fmod
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
fmod (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_fmod
< T, T >, M, N >, M, N > 
fmod (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_fmod< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
fmod (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_atan2
< T1, T2 >, M, N >, M, N > 
atan2 (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_atan2< T,
typename A::value_type >, M, N >
, M, N > 
atan2 (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_atan2
< typename A::value_type, T >
, M, N >, M, N > 
atan2 (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_atan2< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
atan2 (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_atan2< T, T >, M, N >
, M, N > 
atan2 (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_atan2
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
atan2 (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_atan2
< T, T >, M, N >, M, N > 
atan2 (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_atan2< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
atan2 (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_asinh
< T >, M, N >, M, N > 
asinh (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_asinh< typename
A::value_type >, M, N >, M, N > 
asinh (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_acosh
< T >, M, N >, M, N > 
acosh (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_acosh< typename
A::value_type >, M, N >, M, N > 
acosh (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_atanh
< T >, M, N >, M, N > 
atanh (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_atanh< typename
A::value_type >, M, N >, M, N > 
atanh (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_cbrt
< T >, M, N >, M, N > 
cbrt (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_cbrt< typename
A::value_type >, M, N >, M, N > 
cbrt (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_expm1
< T >, M, N >, M, N > 
expm1 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_expm1< typename
A::value_type >, M, N >, M, N > 
expm1 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_log1p
< T >, M, N >, M, N > 
log1p (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_log1p< typename
A::value_type >, M, N >, M, N > 
log1p (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_erf< T >
, M, N >, M, N > 
erf (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_erf< typename
A::value_type >, M, N >, M, N > 
erf (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_erfc
< T >, M, N >, M, N > 
erfc (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_erfc< typename
A::value_type >, M, N >, M, N > 
erfc (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_lgamma
< T >, M, N >, M, N > 
lgamma (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_lgamma< typename
A::value_type >, M, N >, M, N > 
lgamma (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_rint
< T >, M, N >, M, N > 
rint (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_rint< typename
A::value_type >, M, N >, M, N > 
rint (const FMExprNode< A, M, N > &a)
 
template<class T1 , class T2 , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, M, N >
::const_iterator, __ltl_hypot
< T1, T2 >, M, N >, M, N > 
hypot (const FMatrix< T1, M, N > &a, const FMatrix< T2, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator, FMExprNode
< A, M, N >, __ltl_hypot< T,
typename A::value_type >, M, N >
, M, N > 
hypot (const FMatrix< T, M, N > &a, const FMExprNode< A, M, N > &b)
 
template<class A , class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_hypot
< typename A::value_type, T >
, M, N >, M, N > 
hypot (const FMExprNode< A, M, N > &a, const FMatrix< T, M, N > &b)
 
template<class A , class B , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< A, M, N >
, FMExprNode< B, M, N >
, __ltl_hypot< typename
A::value_type, typename
B::value_type >, M, N >, M, N > 
hypot (const FMExprNode< A, M, N > &a, const FMExprNode< B, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< typename FMatrix< T, M, N >
::const_iterator,
FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, __ltl_hypot< T, T >, M, N >
, M, N > 
hypot (const FMatrix< T, M, N > &a, const typename FMatrix< T, M, N >::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprNode< T, M, N >
, FMExprLiteralNode< typename
T::value_type >, __ltl_hypot
< typename T::value_type,
typename T::value_type >, M, N >
, M, N > 
hypot (const FMExprNode< T, M, N > &a, const typename T::value_type &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
FMatrix< T, M, N >::value_type >
, typename FMatrix< T, M, N >
::const_iterator, __ltl_hypot
< T, T >, M, N >, M, N > 
hypot (const typename FMatrix< T, M, N >::value_type &a, const FMatrix< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprBinopNode
< FMExprLiteralNode< typename
T::value_type >, FMExprNode< T,
M, N >, __ltl_hypot< typename
T::value_type, typename
T::value_type >, M, N >, M, N > 
hypot (const typename T::value_type &a, const FMExprNode< T, M, N > &b)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow2
< T >, M, N >, M, N > 
pow2 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow2< typename
A::value_type >, M, N >, M, N > 
pow2 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow3
< T >, M, N >, M, N > 
pow3 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow3< typename
A::value_type >, M, N >, M, N > 
pow3 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow4
< T >, M, N >, M, N > 
pow4 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow4< typename
A::value_type >, M, N >, M, N > 
pow4 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow5
< T >, M, N >, M, N > 
pow5 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow5< typename
A::value_type >, M, N >, M, N > 
pow5 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow6
< T >, M, N >, M, N > 
pow6 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow6< typename
A::value_type >, M, N >, M, N > 
pow6 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow7
< T >, M, N >, M, N > 
pow7 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow7< typename
A::value_type >, M, N >, M, N > 
pow7 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_pow8
< T >, M, N >, M, N > 
pow8 (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_pow8< typename
A::value_type >, M, N >, M, N > 
pow8 (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_abs< T >
, M, N >, M, N > 
abs (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_abs< typename
A::value_type >, M, N >, M, N > 
abs (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_arg< T >
, M, N >, M, N > 
arg (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_arg< typename
A::value_type >, M, N >, M, N > 
arg (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_norm
< T >, M, N >, M, N > 
norm (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_norm< typename
A::value_type >, M, N >, M, N > 
norm (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_real
< T >, M, N >, M, N > 
real (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_real< typename
A::value_type >, M, N >, M, N > 
real (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_imag
< T >, M, N >, M, N > 
imag (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_imag< typename
A::value_type >, M, N >, M, N > 
imag (const FMExprNode< A, M, N > &a)
 
template<class T , int M, int N>
FMExprNode< FMExprUnopNode
< typename FMatrix< T, M, N >
::const_iterator, __ltl_conj
< T >, M, N >, M, N > 
conj (const FMatrix< T, M, N > &a)
 
template<class A , int M, int N>
FMExprNode< FMExprUnopNode
< FMExprNode< A, M, N >
, __ltl_conj< typename
A::value_type >, M, N >, M, N > 
conj (const FMExprNode< A, M, N > &a)
 
template<class Expr , int M, int N>
bool anyof (const FMExprNode< Expr, M, N > &e)
 
template<class T , int M, int N>
bool anyof (FMatrix< T, M, N > &e)
 
template<class Expr , int M, int N>
bool allof (const FMExprNode< Expr, M, N > &e)
 
template<class T , int M, int N>
bool allof (FMatrix< T, M, N > &e)
 
template<class Expr , int M, int N>
bool noneof (const FMExprNode< Expr, M, N > &e)
 
template<class T , int M, int N>
bool noneof (FMatrix< T, M, N > &e)
 
template<class T , int N, int M>
FMExprNode
< TMatTransposeFMExprOp
< typename FMatrix< T, M, N >
::const_iterator, T, N, M >, N,
M > 
transpose (const FMatrix< T, M, N > &m1)
 Global transpose() matrix. More...
 
template<class Expr , int N, int M>
FMExprNode
< TMatTransposeFMExprOp
< FMExprNode< Expr, M, N >
, typename Expr::value_type, N,
M >, N, M > 
transpose (const FMExprNode< Expr, M, N > &m1)
 Global transpose() matrix expression. More...
 
template<class T1 , class T2 , int M, int N, int S>
FVExprNode< TMatVecFVExprOp
< typename FMatrix< T1, M, N >
::const_iterator, typename
FVector< T2, N, S >
::const_iterator, typename
sumtype_trait< typename
promotion_trait< T1, T2 >
::PType >::SumType, M, N >, M > 
dot (const FMatrix< T1, M, N > &m, const FVector< T2, N, S > &v)
 
template<class T1 , class A , int M, int N>
FVExprNode< TMatVecFVExprOp
< typename FMatrix< T1, M, N >
::const_iterator, FVExprNode
< A, N >, typename
sumtype_trait< typename
promotion_trait< T1, typename
A::value_type >::PType >
::SumType, M, N >, M > 
dot (const FMatrix< T1, M, N > &m, const FVExprNode< A, N > &v)
 
template<class A , class T2 , int M, int N, int S>
FVExprNode< TMatVecFVExprOp
< FMExprNode< A, M, N >
, typename FVector< T2, N, S >
::const_iterator, typename
sumtype_trait< typename
promotion_trait< typename
A::value_type, T2 >::PType >
::SumType, M, N >, M > 
dot (const FMExprNode< A, M, N > &m, const FVector< T2, N, S > &v)
 
template<class A , class B , int M, int N>
FVExprNode< TMatVecFVExprOp
< FMExprNode< A, M, N >
, FVExprNode< B, N >, typename
sumtype_trait< typename
promotion_trait< typename
A::value_type, typename
B::value_type >::PType >
::SumType, M, N >, M > 
dot (const FMExprNode< A, M, N > &m, const FVExprNode< B, N > &v)
 
template<class T1 , class T2 , int M, int N, int K>
FMExprNode< TMatMatFMExprOp
< typename FMatrix< T1, M, N >
::const_iterator, typename
FMatrix< T2, N, K >
::const_iterator, typename
sumtype_trait< typename
promotion_trait< T1, T2 >
::PType >::SumType, N >, M, K > 
dot (const FMatrix< T1, M, N > &m1, const FMatrix< T2, N, K > &m2)
 
template<class T1 , class A , int M, int N, int K>
FMExprNode< TMatMatFMExprOp
< typename FMatrix< T1, M, N >
::const_iterator, FMExprNode
< A, N, K >, typename
sumtype_trait< typename
promotion_trait< T1, typename
A::value_type >::PType >
::SumType, N >, M, K > 
dot (const FMatrix< T1, M, N > &m1, const FMExprNode< A, N, K > &m2)
 
template<class A , class T2 , int M, int N, int K>
FMExprNode< TMatMatFMExprOp
< FMExprNode< A, M, N >
, typename FMatrix< T2, N, K >
::const_iterator, typename
sumtype_trait< typename
promotion_trait< typename
A::value_type, T2 >::PType >
::SumType, N >, M, K > 
dot (const FMExprNode< A, M, N > &m1, const FMatrix< T2, N, K > &m2)
 
template<class A , class B , int M, int N, int K>
FMExprNode< TMatMatFMExprOp
< FMExprNode< A, M, N >
, FMExprNode< B, N, K >
, typename sumtype_trait
< typename promotion_trait
< typename A::value_type,
typename B::value_type >
::PType >::SumType, N >, M, K > 
dot (const FMExprNode< A, M, N > &m1, const FMExprNode< B, N, K > &m2)
 

Enumeration Type Documentation

anonymous enum
Enumerator
minStart 
minEnd 

Function Documentation

template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TAdd< T1, T2 >, N >, N > ltl::ltl::operator+ ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TAdd< T, typename A::value_type >, N >, N > ltl::ltl::operator+ ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TAdd< typename A::value_type, T >, N >, N > ltl::ltl::operator+ ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TAdd< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator+ ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TAdd< T, T >, N >, N > ltl::ltl::operator+ ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TAdd< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator+ ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TAdd< T, T >, N >, N > ltl::ltl::operator+ ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TAdd< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator+ ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TSub< T1, T2 >, N >, N > ltl::ltl::operator- ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TSub< T, typename A::value_type >, N >, N > ltl::ltl::operator- ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TSub< typename A::value_type, T >, N >, N > ltl::ltl::operator- ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TSub< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator- ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TSub< T, T >, N >, N > ltl::ltl::operator- ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TSub< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator- ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TSub< T, T >, N >, N > ltl::ltl::operator- ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TSub< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator- ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TMul< T1, T2 >, N >, N > ltl::ltl::operator* ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TMul< T, typename A::value_type >, N >, N > ltl::ltl::operator* ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TMul< typename A::value_type, T >, N >, N > ltl::ltl::operator* ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TMul< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator* ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TMul< T, T >, N >, N > ltl::ltl::operator* ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TMul< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator* ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TMul< T, T >, N >, N > ltl::ltl::operator* ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TMul< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator* ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TDiv< T1, T2 >, N >, N > ltl::ltl::operator/ ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TDiv< T, typename A::value_type >, N >, N > ltl::ltl::operator/ ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TDiv< typename A::value_type, T >, N >, N > ltl::ltl::operator/ ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TDiv< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator/ ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TDiv< T, T >, N >, N > ltl::ltl::operator/ ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TDiv< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator/ ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TDiv< T, T >, N >, N > ltl::ltl::operator/ ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TDiv< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator/ ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TAnd< T1, T2 >, N >, N > ltl::ltl::operator&& ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TAnd< T, typename A::value_type >, N >, N > ltl::ltl::operator&& ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TAnd< typename A::value_type, T >, N >, N > ltl::ltl::operator&& ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TAnd< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator&& ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TAnd< T, T >, N >, N > ltl::ltl::operator&& ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TAnd< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator&& ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TAnd< T, T >, N >, N > ltl::ltl::operator&& ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TAnd< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator&& ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TOr< T1, T2 >, N >, N > ltl::ltl::operator|| ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TOr< T, typename A::value_type >, N >, N > ltl::ltl::operator|| ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TOr< typename A::value_type, T >, N >, N > ltl::ltl::operator|| ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TOr< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator|| ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TOr< T, T >, N >, N > ltl::ltl::operator|| ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TOr< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator|| ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TOr< T, T >, N >, N > ltl::ltl::operator|| ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TOr< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator|| ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TBitAnd< T1, T2 >, N >, N > ltl::ltl::operator& ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TBitAnd< T, typename A::value_type >, N >, N > ltl::ltl::operator& ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TBitAnd< typename A::value_type, T >, N >, N > ltl::ltl::operator& ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TBitAnd< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator& ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TBitAnd< T, T >, N >, N > ltl::ltl::operator& ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TBitAnd< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator& ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TBitAnd< T, T >, N >, N > ltl::ltl::operator& ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TBitAnd< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator& ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TBitOr< T1, T2 >, N >, N > ltl::ltl::operator| ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TBitOr< T, typename A::value_type >, N >, N > ltl::ltl::operator| ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TBitOr< typename A::value_type, T >, N >, N > ltl::ltl::operator| ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TBitOr< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator| ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TBitOr< T, T >, N >, N > ltl::ltl::operator| ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TBitOr< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator| ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TBitOr< T, T >, N >, N > ltl::ltl::operator| ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TBitOr< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator| ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TBitXor< T1, T2 >, N >, N > ltl::ltl::operator^ ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TBitXor< T, typename A::value_type >, N >, N > ltl::ltl::operator^ ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TBitXor< typename A::value_type, T >, N >, N > ltl::ltl::operator^ ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TBitXor< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator^ ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TBitXor< T, T >, N >, N > ltl::ltl::operator^ ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TBitXor< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator^ ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TBitXor< T, T >, N >, N > ltl::ltl::operator^ ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TBitXor< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator^ ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TMod< T1, T2 >, N >, N > ltl::ltl::operator% ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TMod< T, typename A::value_type >, N >, N > ltl::ltl::operator% ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TMod< typename A::value_type, T >, N >, N > ltl::ltl::operator% ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TMod< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator% ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TMod< T, T >, N >, N > ltl::ltl::operator% ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TMod< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator% ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TMod< T, T >, N >, N > ltl::ltl::operator% ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TMod< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator% ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TGT< T1, T2 >, N >, N > ltl::ltl::operator> ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TGT< T, typename A::value_type >, N >, N > ltl::ltl::operator> ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TGT< typename A::value_type, T >, N >, N > ltl::ltl::operator> ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TGT< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator> ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TGT< T, T >, N >, N > ltl::ltl::operator> ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TGT< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator> ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TGT< T, T >, N >, N > ltl::ltl::operator> ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TGT< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator> ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TLT< T1, T2 >, N >, N > ltl::ltl::operator< ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TLT< T, typename A::value_type >, N >, N > ltl::ltl::operator< ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TLT< typename A::value_type, T >, N >, N > ltl::ltl::operator< ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TLT< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator< ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TLT< T, T >, N >, N > ltl::ltl::operator< ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TLT< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator< ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TLT< T, T >, N >, N > ltl::ltl::operator< ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TLT< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator< ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TGE< T1, T2 >, N >, N > ltl::ltl::operator>= ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TGE< T, typename A::value_type >, N >, N > ltl::ltl::operator>= ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TGE< typename A::value_type, T >, N >, N > ltl::ltl::operator>= ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TGE< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator>= ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TGE< T, T >, N >, N > ltl::ltl::operator>= ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TGE< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator>= ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TGE< T, T >, N >, N > ltl::ltl::operator>= ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TGE< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator>= ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TLE< T1, T2 >, N >, N > ltl::ltl::operator<= ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TLE< T, typename A::value_type >, N >, N > ltl::ltl::operator<= ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TLE< typename A::value_type, T >, N >, N > ltl::ltl::operator<= ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TLE< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator<= ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TLE< T, T >, N >, N > ltl::ltl::operator<= ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TLE< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator<= ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TLE< T, T >, N >, N > ltl::ltl::operator<= ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TLE< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator<= ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TNE< T1, T2 >, N >, N > ltl::ltl::operator!= ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TNE< T, typename A::value_type >, N >, N > ltl::ltl::operator!= ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TNE< typename A::value_type, T >, N >, N > ltl::ltl::operator!= ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TNE< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator!= ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TNE< T, T >, N >, N > ltl::ltl::operator!= ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TNE< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator!= ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TNE< T, T >, N >, N > ltl::ltl::operator!= ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TNE< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator!= ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_TEQ< T1, T2 >, N >, N > ltl::ltl::operator== ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_TEQ< T, typename A::value_type >, N >, N > ltl::ltl::operator== ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_TEQ< typename A::value_type, T >, N >, N > ltl::ltl::operator== ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_TEQ< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::operator== ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_TEQ< T, T >, N >, N > ltl::ltl::operator== ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_TEQ< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator== ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_TEQ< T, T >, N >, N > ltl::ltl::operator== ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_TEQ< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::operator== ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_TPlus< T >, N >, N > ltl::ltl::operator+ ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_TPlus< typename A::value_type >, N >, N > ltl::ltl::operator+ ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_TMinus< T >, N >, N > ltl::ltl::operator- ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_TMinus< typename A::value_type >, N >, N > ltl::ltl::operator- ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_TNot< T >, N >, N > ltl::ltl::operator! ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_TNot< typename A::value_type >, N >, N > ltl::ltl::operator! ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_TNeg< T >, N >, N > ltl::ltl::operator~ ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_TNeg< typename A::value_type >, N >, N > ltl::ltl::operator~ ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_sin< T >, N >, N > ltl::ltl::sin ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_sin< typename A::value_type >, N >, N > ltl::ltl::sin ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_cos< T >, N >, N > ltl::ltl::cos ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_cos< typename A::value_type >, N >, N > ltl::ltl::cos ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_tan< T >, N >, N > ltl::ltl::tan ( const FVector< T, N, S > &  a)
inline

Referenced by ltl::CCS_TAN::x_nc().

template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_tan< typename A::value_type >, N >, N > ltl::ltl::tan ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_asin< T >, N >, N > ltl::ltl::asin ( const FVector< T, N, S > &  a)
inline

Referenced by ltl::CCS::cc_(), and ltl::CCS::nc_cc().

template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_asin< typename A::value_type >, N >, N > ltl::ltl::asin ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_acos< T >, N >, N > ltl::ltl::acos ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_acos< typename A::value_type >, N >, N > ltl::ltl::acos ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_atan< T >, N >, N > ltl::ltl::atan ( const FVector< T, N, S > &  a)
inline

Referenced by ltl::CCS_TAN::nc_().

template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_atan< typename A::value_type >, N >, N > ltl::ltl::atan ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_sinh< T >, N >, N > ltl::ltl::sinh ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_sinh< typename A::value_type >, N >, N > ltl::ltl::sinh ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_cosh< T >, N >, N > ltl::ltl::cosh ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_cosh< typename A::value_type >, N >, N > ltl::ltl::cosh ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_tanh< T >, N >, N > ltl::ltl::tanh ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_tanh< typename A::value_type >, N >, N > ltl::ltl::tanh ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_exp< T >, N >, N > ltl::ltl::exp ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_exp< typename A::value_type >, N >, N > ltl::ltl::exp ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_log< T >, N >, N > ltl::ltl::log ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_log< typename A::value_type >, N >, N > ltl::ltl::log ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_log10< T >, N >, N > ltl::ltl::log10 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_log10< typename A::value_type >, N >, N > ltl::ltl::log10 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_sqrt< T >, N >, N > ltl::ltl::sqrt ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_sqrt< typename A::value_type >, N >, N > ltl::ltl::sqrt ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_fabs< T >, N >, N > ltl::ltl::fabs ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_fabs< typename A::value_type >, N >, N > ltl::ltl::fabs ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_floor< T >, N >, N > ltl::ltl::floor ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_floor< typename A::value_type >, N >, N > ltl::ltl::floor ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_ceil< T >, N >, N > ltl::ltl::ceil ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_ceil< typename A::value_type >, N >, N > ltl::ltl::ceil ( const FVExprNode< A, N > &  a)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_pow< T1, T2 >, N >, N > ltl::ltl::pow ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_pow< T, typename A::value_type >, N >, N > ltl::ltl::pow ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_pow< typename A::value_type, T >, N >, N > ltl::ltl::pow ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_pow< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::pow ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_pow< T, T >, N >, N > ltl::ltl::pow ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_pow< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::pow ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_pow< T, T >, N >, N > ltl::ltl::pow ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_pow< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::pow ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_fmod< T1, T2 >, N >, N > ltl::ltl::fmod ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_fmod< T, typename A::value_type >, N >, N > ltl::ltl::fmod ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_fmod< typename A::value_type, T >, N >, N > ltl::ltl::fmod ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_fmod< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::fmod ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_fmod< T, T >, N >, N > ltl::ltl::fmod ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_fmod< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::fmod ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_fmod< T, T >, N >, N > ltl::ltl::fmod ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_fmod< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::fmod ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_atan2< T1, T2 >, N >, N > ltl::ltl::atan2 ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_atan2< T, typename A::value_type >, N >, N > ltl::ltl::atan2 ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_atan2< typename A::value_type, T >, N >, N > ltl::ltl::atan2 ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_atan2< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::atan2 ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_atan2< T, T >, N >, N > ltl::ltl::atan2 ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_atan2< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::atan2 ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_atan2< T, T >, N >, N > ltl::ltl::atan2 ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_atan2< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::atan2 ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_asinh< T >, N >, N > ltl::ltl::asinh ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_asinh< typename A::value_type >, N >, N > ltl::ltl::asinh ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_acosh< T >, N >, N > ltl::ltl::acosh ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_acosh< typename A::value_type >, N >, N > ltl::ltl::acosh ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_atanh< T >, N >, N > ltl::ltl::atanh ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_atanh< typename A::value_type >, N >, N > ltl::ltl::atanh ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_cbrt< T >, N >, N > ltl::ltl::cbrt ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_cbrt< typename A::value_type >, N >, N > ltl::ltl::cbrt ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_expm1< T >, N >, N > ltl::ltl::expm1 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_expm1< typename A::value_type >, N >, N > ltl::ltl::expm1 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_log1p< T >, N >, N > ltl::ltl::log1p ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_log1p< typename A::value_type >, N >, N > ltl::ltl::log1p ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_erf< T >, N >, N > ltl::ltl::erf ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_erf< typename A::value_type >, N >, N > ltl::ltl::erf ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_erfc< T >, N >, N > ltl::ltl::erfc ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_erfc< typename A::value_type >, N >, N > ltl::ltl::erfc ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_lgamma< T >, N >, N > ltl::ltl::lgamma ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_lgamma< typename A::value_type >, N >, N > ltl::ltl::lgamma ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_rint< T >, N >, N > ltl::ltl::rint ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_rint< typename A::value_type >, N >, N > ltl::ltl::rint ( const FVExprNode< A, N > &  a)
inline
template<class T1 , class T2 , int N, int S1, int S2>
FVExprNode< FVExprBinopNode< typename FVector< T1, N, S1 >::const_iterator, typename FVector< T2, N, S2 >::const_iterator, __ltl_hypot< T1, T2 >, N >, N > ltl::ltl::hypot ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline

Referenced by ltl::CCS_TAN::nc_().

template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprNode< A, N >, __ltl_hypot< T, typename A::value_type >, N >, N > ltl::ltl::hypot ( const FVector< T, N, S > &  a,
const FVExprNode< A, N > &  b 
)
inline
template<class A , class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, typename FVector< T, N, S >::const_iterator, __ltl_hypot< typename A::value_type, T >, N >, N > ltl::ltl::hypot ( const FVExprNode< A, N > &  a,
const FVector< T, N, S > &  b 
)
inline
template<class A , class B , int N>
FVExprNode< FVExprBinopNode< FVExprNode< A, N >, FVExprNode< B, N >, __ltl_hypot< typename A::value_type, typename B::value_type >, N >, N > ltl::ltl::hypot ( const FVExprNode< A, N > &  a,
const FVExprNode< B, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< typename FVector< T, N, S >::const_iterator, FVExprLiteralNode< typename FVector< T, N, S >::value_type >, __ltl_hypot< T, T >, N >, N > ltl::ltl::hypot ( const FVector< T, N, S > &  a,
const typename FVector< T, N, S >::value_type &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprNode< T, N >, FVExprLiteralNode< typename T::value_type >, __ltl_hypot< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::hypot ( const FVExprNode< T, N > &  a,
const typename T::value_type &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename FVector< T, N, S >::value_type >, typename FVector< T, N, S >::const_iterator, __ltl_hypot< T, T >, N >, N > ltl::ltl::hypot ( const typename FVector< T, N, S >::value_type &  a,
const FVector< T, N, S > &  b 
)
inline
template<class T , int N>
FVExprNode< FVExprBinopNode< FVExprLiteralNode< typename T::value_type >, FVExprNode< T, N >, __ltl_hypot< typename T::value_type, typename T::value_type >, N >, N > ltl::ltl::hypot ( const typename T::value_type &  a,
const FVExprNode< T, N > &  b 
)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow2< T >, N >, N > ltl::ltl::pow2 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow2< typename A::value_type >, N >, N > ltl::ltl::pow2 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow3< T >, N >, N > ltl::ltl::pow3 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow3< typename A::value_type >, N >, N > ltl::ltl::pow3 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow4< T >, N >, N > ltl::ltl::pow4 ( const FVector< T, N, S > &  a)
inline

Referenced by ltl::robust_sigma().

template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow4< typename A::value_type >, N >, N > ltl::ltl::pow4 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow5< T >, N >, N > ltl::ltl::pow5 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow5< typename A::value_type >, N >, N > ltl::ltl::pow5 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow6< T >, N >, N > ltl::ltl::pow6 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow6< typename A::value_type >, N >, N > ltl::ltl::pow6 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow7< T >, N >, N > ltl::ltl::pow7 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow7< typename A::value_type >, N >, N > ltl::ltl::pow7 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_pow8< T >, N >, N > ltl::ltl::pow8 ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_pow8< typename A::value_type >, N >, N > ltl::ltl::pow8 ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_abs< T >, N >, N > ltl::ltl::abs ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_abs< typename A::value_type >, N >, N > ltl::ltl::abs ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_arg< T >, N >, N > ltl::ltl::arg ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_arg< typename A::value_type >, N >, N > ltl::ltl::arg ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_norm< T >, N >, N > ltl::ltl::norm ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_norm< typename A::value_type >, N >, N > ltl::ltl::norm ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_real< T >, N >, N > ltl::ltl::real ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_real< typename A::value_type >, N >, N > ltl::ltl::real ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_imag< T >, N >, N > ltl::ltl::imag ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_imag< typename A::value_type >, N >, N > ltl::ltl::imag ( const FVExprNode< A, N > &  a)
inline
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_conj< T >, N >, N > ltl::ltl::conj ( const FVector< T, N, S > &  a)
inline
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_conj< typename A::value_type >, N >, N > ltl::ltl::conj ( const FVExprNode< A, N > &  a)
inline
template<class Expr , int N>
bool ltl::ltl::anyof ( const FVExprNode< Expr, N > &  e)
inline
template<class T , int N, int S>
bool ltl::ltl::anyof ( FVector< T, N, S > &  e)
inline
template<class Expr , int N>
bool ltl::ltl::allof ( const FVExprNode< Expr, N > &  e)
inline
template<class T , int N, int S>
bool ltl::ltl::allof ( FVector< T, N, S > &  e)
inline
template<class Expr , int N>
bool ltl::ltl::noneof ( const FVExprNode< Expr, N > &  e)
inline
template<class T , int N, int S>
bool ltl::ltl::noneof ( FVector< T, N, S > &  e)
inline
template<class T1 , class T2 , int N, int S1, int S2>
sumtype_trait< typename promotion_trait< T1, T2 >::PType >::SumType ltl::ltl::dot ( const FVector< T1, N, S1 > &  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class T1 , class T2 , int N, int S1>
sumtype_trait< typename promotion_trait< T1, T2 >::PType >::SumType ltl::ltl::dot ( const FVector< T1, N, S1 > &  a,
const FVExprNode< T2, N > &  b 
)
inline
template<class T1 , class T2 , int N, int S2>
sumtype_trait< typename promotion_trait< T1, T2 >::PType >::SumType ltl::ltl::dot ( FVExprNode< T1, N >  a,
const FVector< T2, N, S2 > &  b 
)
inline
template<class T1 , class T2 , int N>
sumtype_trait< typename promotion_trait< T1, T2 >::PType >::SumType ltl::ltl::dot ( const FVExprNode< T1, N > &  a,
const FVExprNode< T2, N > &  b 
)
inline
template<class Expr , int N>
sumtype_trait< typename Expr::value_type >::SumType ltl::ltl::sum ( const FVExprNode< Expr, N > &  e)
inline
template<class T , int N, int S>
sumtype_trait< T >::SumType ltl::ltl::sum ( const FVector< T, N, S > &  e)
inline
template<class Expr , int N>
sumtype_trait< typename Expr::value_type >::SumType ltl::ltl::sum2 ( const FVExprNode< Expr, N > &  e)
inline
template<class T , int N, int S>
sumtype_trait< T >::SumType ltl::ltl::sum2 ( const FVector< T, N, S > &  e)
inline
template<class Expr , int N>
sumtype_trait< typename Expr::value_type >::SumType ltl::ltl::product ( const FVExprNode< Expr, N > &  e)
inline
template<class T , int N, int S>
sumtype_trait< T >::SumType ltl::ltl::product ( const FVector< T, N, S > &  e)
inline
template<int N>
std::istream & ltl::ltl::operator>> ( std::istream &  is,
Shape< N > &  s 
)
template<int N>
std::ostream& ltl::ltl::operator<< ( std::ostream &  os,
const Shape< N > &  s 
)
template<class T , int N>
std::ostream& ltl::ltl::operator<< ( std::ostream &  os,
const FixedVector< T, N > &  x 
)
template<typename A , typename T >
const Shape<A::dims>* ltl::ltl::_expr_getshape ( const A &  a,
const ExprLiteralNode< T > &   
)
inline
template<typename A , typename T >
const Shape<A::dims>* ltl::ltl::_expr_getshape ( const ExprLiteralNode< T > &  ,
const A &  a 
)
inline
template<typename A , typename T >
int ltl::ltl::_expr_getalign ( const A &  a,
const ExprLiteralNode< T > &   
)
inline
template<typename T , typename A >
int ltl::ltl::_expr_getalign ( const ExprLiteralNode< T > &  ,
const A &  a 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TAdd <T1, T2>, N>, N> ltl::ltl::operator+ ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TAdd <T1, typename T2::value_type>, N>, N> ltl::ltl::operator+ ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TAdd <typename T1::value_type, T2>, N>, N> ltl::ltl::operator+ ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TAdd <T1, T2>, N>, N> ltl::ltl::operator+ ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TAdd <T1, T2>, N>, N> ltl::ltl::operator+ ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TAdd <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator+ ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TAdd <typename T1::value_type, T2>, N>, N> ltl::ltl::operator+ ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TAdd <T1, typename T2::value_type>, N>, N> ltl::ltl::operator+ ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TSub <T1, T2>, N>, N> ltl::ltl::operator- ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TSub <T1, typename T2::value_type>, N>, N> ltl::ltl::operator- ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TSub <typename T1::value_type, T2>, N>, N> ltl::ltl::operator- ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TSub <T1, T2>, N>, N> ltl::ltl::operator- ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TSub <T1, T2>, N>, N> ltl::ltl::operator- ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TSub <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator- ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TSub <typename T1::value_type, T2>, N>, N> ltl::ltl::operator- ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TSub <T1, typename T2::value_type>, N>, N> ltl::ltl::operator- ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TMul <T1, T2>, N>, N> ltl::ltl::operator* ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TMul <T1, typename T2::value_type>, N>, N> ltl::ltl::operator* ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TMul <typename T1::value_type, T2>, N>, N> ltl::ltl::operator* ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TMul <T1, T2>, N>, N> ltl::ltl::operator* ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TMul <T1, T2>, N>, N> ltl::ltl::operator* ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TMul <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator* ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TMul <typename T1::value_type, T2>, N>, N> ltl::ltl::operator* ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TMul <T1, typename T2::value_type>, N>, N> ltl::ltl::operator* ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TDiv <T1, T2>, N>, N> ltl::ltl::operator/ ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TDiv <T1, typename T2::value_type>, N>, N> ltl::ltl::operator/ ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TDiv <typename T1::value_type, T2>, N>, N> ltl::ltl::operator/ ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TDiv <T1, T2>, N>, N> ltl::ltl::operator/ ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TDiv <T1, T2>, N>, N> ltl::ltl::operator/ ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TDiv <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator/ ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TDiv <typename T1::value_type, T2>, N>, N> ltl::ltl::operator/ ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TDiv <T1, typename T2::value_type>, N>, N> ltl::ltl::operator/ ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TAnd <T1, T2>, N>, N> ltl::ltl::operator&& ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TAnd <T1, typename T2::value_type>, N>, N> ltl::ltl::operator&& ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TAnd <typename T1::value_type, T2>, N>, N> ltl::ltl::operator&& ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TAnd <T1, T2>, N>, N> ltl::ltl::operator&& ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TAnd <T1, T2>, N>, N> ltl::ltl::operator&& ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TAnd <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator&& ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TAnd <typename T1::value_type, T2>, N>, N> ltl::ltl::operator&& ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TAnd <T1, typename T2::value_type>, N>, N> ltl::ltl::operator&& ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TOr <T1, T2>, N>, N> ltl::ltl::operator|| ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TOr <T1, typename T2::value_type>, N>, N> ltl::ltl::operator|| ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TOr <typename T1::value_type, T2>, N>, N> ltl::ltl::operator|| ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TOr <T1, T2>, N>, N> ltl::ltl::operator|| ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TOr <T1, T2>, N>, N> ltl::ltl::operator|| ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TOr <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator|| ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TOr <typename T1::value_type, T2>, N>, N> ltl::ltl::operator|| ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TOr <T1, typename T2::value_type>, N>, N> ltl::ltl::operator|| ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TBitAnd <T1, T2>, N>, N> ltl::ltl::operator& ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TBitAnd <T1, typename T2::value_type>, N>, N> ltl::ltl::operator& ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TBitAnd <typename T1::value_type, T2>, N>, N> ltl::ltl::operator& ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TBitAnd <T1, T2>, N>, N> ltl::ltl::operator& ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TBitAnd <T1, T2>, N>, N> ltl::ltl::operator& ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TBitAnd <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator& ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TBitAnd <typename T1::value_type, T2>, N>, N> ltl::ltl::operator& ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TBitAnd <T1, typename T2::value_type>, N>, N> ltl::ltl::operator& ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TBitOr <T1, T2>, N>, N> ltl::ltl::operator| ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TBitOr <T1, typename T2::value_type>, N>, N> ltl::ltl::operator| ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TBitOr <typename T1::value_type, T2>, N>, N> ltl::ltl::operator| ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TBitOr <T1, T2>, N>, N> ltl::ltl::operator| ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TBitOr <T1, T2>, N>, N> ltl::ltl::operator| ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TBitOr <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator| ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TBitOr <typename T1::value_type, T2>, N>, N> ltl::ltl::operator| ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TBitOr <T1, typename T2::value_type>, N>, N> ltl::ltl::operator| ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TBitXor <T1, T2>, N>, N> ltl::ltl::operator^ ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TBitXor <T1, typename T2::value_type>, N>, N> ltl::ltl::operator^ ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TBitXor <typename T1::value_type, T2>, N>, N> ltl::ltl::operator^ ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TBitXor <T1, T2>, N>, N> ltl::ltl::operator^ ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TBitXor <T1, T2>, N>, N> ltl::ltl::operator^ ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TBitXor <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator^ ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TBitXor <typename T1::value_type, T2>, N>, N> ltl::ltl::operator^ ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TBitXor <T1, typename T2::value_type>, N>, N> ltl::ltl::operator^ ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TMod <T1, T2>, N>, N> ltl::ltl::operator% ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TMod <T1, typename T2::value_type>, N>, N> ltl::ltl::operator% ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TMod <typename T1::value_type, T2>, N>, N> ltl::ltl::operator% ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TMod <T1, T2>, N>, N> ltl::ltl::operator% ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TMod <T1, T2>, N>, N> ltl::ltl::operator% ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TMod <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator% ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TMod <typename T1::value_type, T2>, N>, N> ltl::ltl::operator% ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TMod <T1, typename T2::value_type>, N>, N> ltl::ltl::operator% ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TGT <T1, T2>, N>, N> ltl::ltl::operator> ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TGT <T1, typename T2::value_type>, N>, N> ltl::ltl::operator> ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TGT <typename T1::value_type, T2>, N>, N> ltl::ltl::operator> ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TGT <T1, T2>, N>, N> ltl::ltl::operator> ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TGT <T1, T2>, N>, N> ltl::ltl::operator> ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TGT <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator> ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TGT <typename T1::value_type, T2>, N>, N> ltl::ltl::operator> ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TGT <T1, typename T2::value_type>, N>, N> ltl::ltl::operator> ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TLT <T1, T2>, N>, N> ltl::ltl::operator< ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TLT <T1, typename T2::value_type>, N>, N> ltl::ltl::operator< ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TLT <typename T1::value_type, T2>, N>, N> ltl::ltl::operator< ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TLT <T1, T2>, N>, N> ltl::ltl::operator< ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TLT <T1, T2>, N>, N> ltl::ltl::operator< ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TLT <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator< ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TLT <typename T1::value_type, T2>, N>, N> ltl::ltl::operator< ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TLT <T1, typename T2::value_type>, N>, N> ltl::ltl::operator< ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TGE <T1, T2>, N>, N> ltl::ltl::operator>= ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TGE <T1, typename T2::value_type>, N>, N> ltl::ltl::operator>= ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TGE <typename T1::value_type, T2>, N>, N> ltl::ltl::operator>= ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TGE <T1, T2>, N>, N> ltl::ltl::operator>= ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TGE <T1, T2>, N>, N> ltl::ltl::operator>= ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TGE <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator>= ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TGE <typename T1::value_type, T2>, N>, N> ltl::ltl::operator>= ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TGE <T1, typename T2::value_type>, N>, N> ltl::ltl::operator>= ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TLE <T1, T2>, N>, N> ltl::ltl::operator<= ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TLE <T1, typename T2::value_type>, N>, N> ltl::ltl::operator<= ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TLE <typename T1::value_type, T2>, N>, N> ltl::ltl::operator<= ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TLE <T1, T2>, N>, N> ltl::ltl::operator<= ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TLE <T1, T2>, N>, N> ltl::ltl::operator<= ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TLE <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator<= ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TLE <typename T1::value_type, T2>, N>, N> ltl::ltl::operator<= ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TLE <T1, typename T2::value_type>, N>, N> ltl::ltl::operator<= ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TNE <T1, T2>, N>, N> ltl::ltl::operator!= ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TNE <T1, typename T2::value_type>, N>, N> ltl::ltl::operator!= ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TNE <typename T1::value_type, T2>, N>, N> ltl::ltl::operator!= ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TNE <T1, T2>, N>, N> ltl::ltl::operator!= ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TNE <T1, T2>, N>, N> ltl::ltl::operator!= ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TNE <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator!= ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TNE <typename T1::value_type, T2>, N>, N> ltl::ltl::operator!= ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TNE <T1, typename T2::value_type>, N>, N> ltl::ltl::operator!= ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_TEQ <T1, T2>, N>, N> ltl::ltl::operator== ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_TEQ <T1, typename T2::value_type>, N>, N> ltl::ltl::operator== ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_TEQ <typename T1::value_type, T2>, N>, N> ltl::ltl::operator== ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_TEQ <T1, T2>, N>, N> ltl::ltl::operator== ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_TEQ <T1, T2>, N>, N> ltl::ltl::operator== ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_TEQ <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::operator== ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_TEQ <typename T1::value_type, T2>, N>, N> ltl::ltl::operator== ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_TEQ <T1, typename T2::value_type>, N>, N> ltl::ltl::operator== ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_TPlus <typename T::value_type>, N>, N> ltl::ltl::operator+ ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_TMinus <typename T::value_type>, N>, N> ltl::ltl::operator- ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_TNot <typename T::value_type>, N>, N> ltl::ltl::operator! ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_TNeg <typename T::value_type>, N>, N> ltl::ltl::operator~ ( const ExprBase< T, N > &  a)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_feq <T1, T2>, N>, N> ltl::ltl::feq ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_feq <T1, typename T2::value_type>, N>, N> ltl::ltl::feq ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_feq <typename T1::value_type, T2>, N>, N> ltl::ltl::feq ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_feq <T1, T2>, N>, N> ltl::ltl::feq ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_feq <T1, T2>, N>, N> ltl::ltl::feq ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_feq <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::feq ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_feq <typename T1::value_type, T2>, N>, N> ltl::ltl::feq ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_feq <T1, typename T2::value_type>, N>, N> ltl::ltl::feq ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_fneq <T1, T2>, N>, N> ltl::ltl::fneq ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_fneq <T1, typename T2::value_type>, N>, N> ltl::ltl::fneq ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_fneq <typename T1::value_type, T2>, N>, N> ltl::ltl::fneq ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_fneq <T1, T2>, N>, N> ltl::ltl::fneq ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_fneq <T1, T2>, N>, N> ltl::ltl::fneq ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_fneq <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::fneq ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_fneq <typename T1::value_type, T2>, N>, N> ltl::ltl::fneq ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_fneq <T1, typename T2::value_type>, N>, N> ltl::ltl::fneq ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_sin <typename T::value_type>, N>, N> ltl::ltl::sin ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_cos <typename T::value_type>, N>, N> ltl::ltl::cos ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_tan <typename T::value_type>, N>, N> ltl::ltl::tan ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_asin <typename T::value_type>, N>, N> ltl::ltl::asin ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_acos <typename T::value_type>, N>, N> ltl::ltl::acos ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_atan <typename T::value_type>, N>, N> ltl::ltl::atan ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_sinh <typename T::value_type>, N>, N> ltl::ltl::sinh ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_cosh <typename T::value_type>, N>, N> ltl::ltl::cosh ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_tanh <typename T::value_type>, N>, N> ltl::ltl::tanh ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_exp <typename T::value_type>, N>, N> ltl::ltl::exp ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_log <typename T::value_type>, N>, N> ltl::ltl::log ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_log10 <typename T::value_type>, N>, N> ltl::ltl::log10 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_sqrt <typename T::value_type>, N>, N> ltl::ltl::sqrt ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_fabs <typename T::value_type>, N>, N> ltl::ltl::fabs ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_floor <typename T::value_type>, N>, N> ltl::ltl::floor ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_ceil <typename T::value_type>, N>, N> ltl::ltl::ceil ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_round <typename T::value_type>, N>, N> ltl::ltl::round ( const ExprBase< T, N > &  a)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_pow <T1, T2>, N>, N> ltl::ltl::pow ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_pow <T1, typename T2::value_type>, N>, N> ltl::ltl::pow ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_pow <typename T1::value_type, T2>, N>, N> ltl::ltl::pow ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_pow <T1, T2>, N>, N> ltl::ltl::pow ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_pow <T1, T2>, N>, N> ltl::ltl::pow ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_pow <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::pow ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_pow <typename T1::value_type, T2>, N>, N> ltl::ltl::pow ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_pow <T1, typename T2::value_type>, N>, N> ltl::ltl::pow ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_fmod <T1, T2>, N>, N> ltl::ltl::fmod ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_fmod <T1, typename T2::value_type>, N>, N> ltl::ltl::fmod ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_fmod <typename T1::value_type, T2>, N>, N> ltl::ltl::fmod ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_fmod <T1, T2>, N>, N> ltl::ltl::fmod ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_fmod <T1, T2>, N>, N> ltl::ltl::fmod ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_fmod <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::fmod ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_fmod <typename T1::value_type, T2>, N>, N> ltl::ltl::fmod ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_fmod <T1, typename T2::value_type>, N>, N> ltl::ltl::fmod ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_atan2 <T1, T2>, N>, N> ltl::ltl::atan2 ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_atan2 <T1, typename T2::value_type>, N>, N> ltl::ltl::atan2 ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_atan2 <typename T1::value_type, T2>, N>, N> ltl::ltl::atan2 ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_atan2 <T1, T2>, N>, N> ltl::ltl::atan2 ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_atan2 <T1, T2>, N>, N> ltl::ltl::atan2 ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_atan2 <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::atan2 ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_atan2 <typename T1::value_type, T2>, N>, N> ltl::ltl::atan2 ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_atan2 <T1, typename T2::value_type>, N>, N> ltl::ltl::atan2 ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_asinh <typename T::value_type>, N>, N> ltl::ltl::asinh ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_acosh <typename T::value_type>, N>, N> ltl::ltl::acosh ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_atanh <typename T::value_type>, N>, N> ltl::ltl::atanh ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_cbrt <typename T::value_type>, N>, N> ltl::ltl::cbrt ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_expm1 <typename T::value_type>, N>, N> ltl::ltl::expm1 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_log1p <typename T::value_type>, N>, N> ltl::ltl::log1p ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_erf <typename T::value_type>, N>, N> ltl::ltl::erf ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_erfc <typename T::value_type>, N>, N> ltl::ltl::erfc ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_lgamma <typename T::value_type>, N>, N> ltl::ltl::lgamma ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_rint <typename T::value_type>, N>, N> ltl::ltl::rint ( const ExprBase< T, N > &  a)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, typename MArray<T2,N>::ConstIterator, __ltl_hypot <T1, T2>, N>, N> ltl::ltl::hypot ( const MArray< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprNode<T2,N>, __ltl_hypot <T1, typename T2::value_type>, N>, N> ltl::ltl::hypot ( const MArray< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, typename MArray<T2,N>::ConstIterator, __ltl_hypot <typename T1::value_type, T2>, N>, N> ltl::ltl::hypot ( const ExprNode< T1, N > &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<typename MArray<T1,N>::ConstIterator, ExprLiteralNode<T2>, __ltl_hypot <T1, T2>, N>, N> ltl::ltl::hypot ( const MArray< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, typename MArray<T2,N>::ConstIterator, __ltl_hypot <T1, T2>, N>, N> ltl::ltl::hypot ( const T1 &  a,
const MArray< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprNode<T2,N>, __ltl_hypot <typename T1::value_type, typename T2::value_type>, N>, N> ltl::ltl::hypot ( const ExprNode< T1, N > &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprNode<T1,N>, ExprLiteralNode<T2>, __ltl_hypot <typename T1::value_type, T2>, N>, N> ltl::ltl::hypot ( const ExprNode< T1, N > &  a,
const T2 &  b 
)
inline
template<typename T1 , typename T2 , int N>
ExprNode<ExprBinopNode<ExprLiteralNode<T1>, ExprNode<T2,N>, __ltl_hypot <T1, typename T2::value_type>, N>, N> ltl::ltl::hypot ( const T1 &  a,
const ExprNode< T2, N > &  b 
)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_fpclassify <typename T::value_type>, N>, N> ltl::ltl::fpclassify ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_isfinite <typename T::value_type>, N>, N> ltl::ltl::isfinite ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_isinf <typename T::value_type>, N>, N> ltl::ltl::isinf ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_isnan <typename T::value_type>, N>, N> ltl::ltl::isnan ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_isnormal <typename T::value_type>, N>, N> ltl::ltl::isnormal ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow2 <typename T::value_type>, N>, N> ltl::ltl::pow2 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow3 <typename T::value_type>, N>, N> ltl::ltl::pow3 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow4 <typename T::value_type>, N>, N> ltl::ltl::pow4 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow5 <typename T::value_type>, N>, N> ltl::ltl::pow5 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow6 <typename T::value_type>, N>, N> ltl::ltl::pow6 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow7 <typename T::value_type>, N>, N> ltl::ltl::pow7 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_pow8 <typename T::value_type>, N>, N> ltl::ltl::pow8 ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_abs <typename T::value_type>, N>, N> ltl::ltl::abs ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_arg <typename T::value_type>, N>, N> ltl::ltl::arg ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_norm <typename T::value_type>, N>, N> ltl::ltl::norm ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_real <typename T::value_type>, N>, N> ltl::ltl::real ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_imag <typename T::value_type>, N>, N> ltl::ltl::imag ( const ExprBase< T, N > &  a)
inline
template<typename T , int N>
ExprNode<ExprUnopNode<typename ExprNodeType<T>::expr_type, __ltl_conj <typename T::value_type>, N>, N> ltl::ltl::conj ( const ExprBase< T, N > &  a)
inline
template<class T , int N, class E >
void ltl::ltl::eval_assign_expr ( MArray< T, N > &  a,
ExprNode< E, N > &  e 
)
inline

This function is called from MArray::operator= ( ExprNode<>& e ) to actually perform the evaluation and assignment

template<class T , int N, class E >
void ltl::ltl::eval_assign_expr_1 ( MArray< T, N > &  a,
ExprNode< E, N > &  e 
)

We are dealing with the 1 dimensional scalar case here.

template<class T , int N, class E >
void ltl::ltl::eval_assign_expr_N ( MArray< T, N > &  a,
ExprNode< E, N > &  e 
)

this handles the N-dimensional case

template<class T , int N, class E >
void ltl::ltl::eval_with_index_iter ( MArray< T, N > &  a,
ExprNode< E, N > &  e 
)
template<typename T , int N, typename Expr >
void ltl::ltl::eval_with_convolution ( MArray< T, N > &  ,
ExprNode< Expr, N > &   
)
template<typename T , typename Expr >
void ltl::ltl::eval_with_convolution ( MArray< T, 1 > &  A,
ExprNode< Expr, 1 > &  E 
)
template<typename T , typename Expr >
void ltl::ltl::eval_with_convolution ( MArray< T, 2 > &  A,
ExprNode< Expr, 2 > &  E 
)
template<typename T , typename Expr >
void ltl::ltl::eval_with_convolution ( MArray< T, 3 > &  A,
ExprNode< Expr, 3 > &  E 
)