LTL  2.0.x
Classes | Namespaces | Macros | Enumerations | Functions
marquardt.h File Reference

Classes

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

Namespaces

 ltl
 
 ltl::ltl
 

Macros

#define __LTL_IN_FILE_MARQUARDT__
 

Enumerations

enum  { ltl::ltl::minStart = INT_MIN, ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::conj (const FVExprNode< A, N > &a)
 
template<class Expr , int N>
bool ltl::ltl::anyof (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
bool ltl::ltl::anyof (FVector< T, N, S > &e)
 
template<class Expr , int N>
bool ltl::ltl::allof (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
bool ltl::ltl::allof (FVector< T, N, S > &e)
 
template<class Expr , int N>
bool ltl::ltl::noneof (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
bool ltl::ltl::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 
ltl::ltl::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 
ltl::ltl::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 
ltl::ltl::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 
ltl::ltl::dot (const FVExprNode< T1, N > &a, const FVExprNode< T2, N > &b)
 
template<class Expr , int N>
sumtype_trait< typename
Expr::value_type >::SumType 
ltl::ltl::sum (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
sumtype_trait< T >::SumType ltl::ltl::sum (const FVector< T, N, S > &e)
 
template<class Expr , int N>
sumtype_trait< typename
Expr::value_type >::SumType 
ltl::ltl::sum2 (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
sumtype_trait< T >::SumType ltl::ltl::sum2 (const FVector< T, N, S > &e)
 
template<class Expr , int N>
sumtype_trait< typename
Expr::value_type >::SumType 
ltl::ltl::product (const FVExprNode< Expr, N > &e)
 
template<class T , int N, int S>
sumtype_trait< T >::SumType ltl::ltl::product (const FVector< T, N, S > &e)
 
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 B >
const Shape< A::dims > * ltl::ltl::_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 > * ltl::ltl::_expr_getshape (const A &a, const ExprLiteralNode< T > &)
 
template<typename A , typename T >
const Shape< A::dims > * ltl::ltl::_expr_getshape (const ExprLiteralNode< T > &, const A &a)
 
template<typename A , typename B >
int ltl::ltl::_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 ltl::ltl::_expr_getalign (const A &a, const ExprLiteralNode< T > &)
 
template<typename T , typename A >
int ltl::ltl::_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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::conj (const ExprBase< T, N > &a)
 
template<class T , int N, class E >
void ltl::ltl::eval_assign_expr (MArray< T, N > &a, ExprNode< E, N > &e)
 
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. More...
 
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 More...
 
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)
 
template<typename T1 , int N>
ExprNode< IndexIterDimExpr< T1,
int, N >, N > 
ltl::ltl::indexPosInt (const MArray< T1, N > &a, const int dim)
 
template<typename T1 , int N>
ExprNode< IndexIterDimExpr< T1,
float, N >, N > 
ltl::ltl::indexPosFlt (const MArray< T1, N > &a, const int dim)
 
template<typename T1 , int N>
ExprNode< IndexIterDimExpr< T1,
double, N >, N > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::conj (const FMExprNode< A, M, N > &a)
 
template<class Expr , int M, int N>
bool ltl::ltl::anyof (const FMExprNode< Expr, M, N > &e)
 
template<class T , int M, int N>
bool ltl::ltl::anyof (FMatrix< T, M, N > &e)
 
template<class Expr , int M, int N>
bool ltl::ltl::allof (const FMExprNode< Expr, M, N > &e)
 
template<class T , int M, int N>
bool ltl::ltl::allof (FMatrix< T, M, N > &e)
 
template<class Expr , int M, int N>
bool ltl::ltl::noneof (const FMExprNode< Expr, M, N > &e)
 
template<class T , int M, int N>
bool ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::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 > 
ltl::ltl::dot (const FMExprNode< A, M, N > &m1, const FMExprNode< B, N, K > &m2)
 

Macro Definition Documentation

#define __LTL_IN_FILE_MARQUARDT__