LTL  2.0.x
Classes | Namespaces | Functions
lmfit.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< complex< float > >
 
struct  ltl::ltl::precision_trait< complex< double > >
 
struct  ltl::ltl::precision_trait< 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< A, 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::LMFit< TFUNC, TPAR, NPAR, Solver >
 Marquardt-Levenberg fit to a generic function. More...
 

Namespaces

 ltl
 
 ltl::ltl
 

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_j0< T >, N >, N > ltl::ltl::j0 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_j0< typename A::value_type >, N >, N > ltl::ltl::j0 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_j1< T >, N >, N > ltl::ltl::j1 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_j1< typename A::value_type >, N >, N > ltl::ltl::j1 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_y0< T >, N >, N > ltl::ltl::y0 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_y0< typename A::value_type >, N >, N > ltl::ltl::y0 (const FVExprNode< A, N > &a)
 
template<class T , int N, int S>
FVExprNode< FVExprUnopNode< typename FVector< T, N, S >::const_iterator, __ltl_y1< T >, N >, N > ltl::ltl::y1 (const FVector< T, N, S > &a)
 
template<class A , int N>
FVExprNode< FVExprUnopNode< FVExprNode< A, N >, __ltl_y1< typename A::value_type >, N >, N > ltl::ltl::y1 (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)