LTL  2.0.x
Classes | Macros | Typedefs | Enumerations | Enumerator | Functions | Variables | Friends
Assignment overloads

Classes

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, true >
 
class  ltl::ltl::tFMSplitLoop< A, B, operation, M, N, false >
 
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::tMBoolSplitLoop< Expr, M, N, true >
 
class  ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >
 
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::tMatVecSplitLoop< A, B, T, N, true >
 
class  ltl::ltl::tMatVecSplitLoop< A, B, T, N, false >
 
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::tMatMatSplitLoop< A, B, T, N, true >
 
class  ltl::ltl::tMatMatSplitLoop< A, B, T, N, false >
 
class  ltl::ltl::tNMatMatLoop< A, B, T, N, 1 >
 
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...
 

Macros

#define FMBINOP_AA(operator, op)
 
#define FMBINOP_EA(operator, op)
 
#define FMBINOP_AE(operator, op)
 
#define FMBINOP_EE(operator, op)
 
#define FMBINOP_AL(operator, op)
 
#define FMBINOP_EL(operator, op)
 
#define FMBINOP_LA(operator, op)
 
#define FMBINOP_LE(operator, op)
 
#define FMUNOP_A(operator, op)
 
#define FMUNOP_E(operator, op)
 
#define DECLARE_FMBINOP(operation, opname)
 
#define DECLARE_FMUNOP(operation, opname)
 
#define DECLARE_FMBINARY_FUNC_(function)
 
#define DECLARE_FMUNARY_FUNC_(function)
 
#define DECLARE_FM_BINARY_FUNC(function, ret_type)
 
#define DECLARE_FM_UNARY_FUNC(function, ret_type)
 
#define MAKE_ASSIGNFM_OP(name, op)
 
#define MAKE_FMEXPR_ASSIGNMENT_OP(op, name)
 
#define MAKE_FMM_ASSIGNMENT_OP(op, name)
 
#define MAKE_FMLITERAL_ASSIGNEMNT_OP(op, name)
 

Typedefs

typedef Op::value_type ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::value_type
 
typedef Op::value_type ltl::ltl::FMExprUnopNode< A, Op, M, N >::value_type
 
typedef T ltl::ltl::FMExprLiteralNode< T >::value_type
 
typedef A::value_type ltl::ltl::FMExprNode< Expr, M, N >::value_type
 
typedef FMExprLiteralNode< T > ltl::ltl::asFMExpr< T >::value_type
 
typedef FMExprNode< T, M, N > ltl::ltl::asFMExpr< FMExprNode< T, M, N > >::value_type
 
typedef FMatrix< T, M, N >
::const_iterator 
ltl::ltl::asFMExpr< FMatrix< T, M, N > >::value_type
 
typedef operation::value_type ltl::ltl::tFMLoop< A, B, operation, M, N >::value_type
 
typedef operation::value_type ltl::ltl::tFMSplitLoop< A, B, operation, M, N, true >::value_type
 
typedef operation::value_type ltl::ltl::tFMSplitLoop< A, B, operation, M, N, false >::value_type
 
typedef operation::value_type ltl::ltl::tMNLoop< A, B, operation, N, I, J >::value_type
 
typedef bool ltl::ltl::tMBoolLoop< Expr, M, N >::value_type
 
typedef bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::value_type
 
typedef bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::value_type
 
typedef bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::value_type
 
typedef bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::value_type
 
typedef bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::value_type
 
typedef T ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::value_type
 
typedef T ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::value_type
 
typedef T ltl::ltl::tMatVecLoop< A, B, T, N >::value_type
 
typedef T ltl::ltl::tMatVecSplitLoop< A, B, T, N, true >::value_type
 
typedef T ltl::ltl::tMatVecSplitLoop< A, B, T, N, false >::value_type
 
typedef T ltl::ltl::tNMatVecLoop< A, B, T, N, J >::value_type
 
typedef T ltl::ltl::tNMatVecLoop< A, B, T, N, 0 >::value_type
 
typedef T ltl::ltl::TMatMatFMExprOp< A, B, T, N >::value_type
 
typedef T ltl::ltl::tMatMatLoop< A, B, T, N >::value_type
 
typedef T ltl::ltl::tMatMatSplitLoop< A, B, T, N, true >::value_type
 
typedef T ltl::ltl::tMatMatSplitLoop< A, B, T, N, false >::value_type
 
typedef T ltl::ltl::tNMatMatLoop< A, B, T, N, K >::value_type
 
typedef T ltl::ltl::tNMatMatLoop< A, B, T, N, 1 >::value_type
 
typedef X ltl::ltl::fm_equ_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_plu_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_min_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_mul_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_div_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_mod_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_xor_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_and_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_bor_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_sle_assign< X, Y >::value_type
 
typedef X ltl::ltl::fm_sri_assign< X, Y >::value_type
 

Enumerations

enum  { ltl::ltl::FMIterConst< T, M, N >::static_size = 1 }
 
enum  { ltl::ltl::FMIter< T, M, N >::static_size = 1 }
 
enum  { ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::static_size = A::static_size + B::static_size }
 
enum  { ltl::ltl::FMExprUnopNode< A, Op, M, N >::static_size = A::static_size }
 
enum  { ltl::ltl::FMExprLiteralNode< T >::static_size = 1 }
 
enum  { ltl::ltl::FMExprNode< Expr, M, N >::static_size = A::static_size }
 
enum  { ltl::ltl::tFMLoop< A, B, operation, M, N >::static_size = A::static_size + B::static_size }
 
enum  { ltl::ltl::tMBoolLoop< Expr, M, N >::static_size = M*N*Expr::static_size }
 
enum  { ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::static_size = 1 }
 
enum  { ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::static_size = N*(A::static_size + B::static_size) }
 
enum  { ltl::ltl::tMatVecLoop< A, B, T, N >::static_size = N*(A::static_size + B::static_size) }
 
enum  { ltl::ltl::TMatMatFMExprOp< A, B, T, N >::static_size = N*(A::static_size + B::static_size) }
 
enum  { ltl::ltl::tMatMatLoop< A, B, T, N >::static_size = N*(A::static_size + B::static_size) }
 
enum  { ltl::ltl::FMatrix< T, M, N >::static_size = 1 }
 Used by expression engine to decide which loops to unroll. More...
 
enum  { ltl::ltl::fm_equ_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_plu_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_min_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_mul_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_div_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_mod_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_xor_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_and_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_bor_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_sle_assign< X, Y >::static_size = 1 }
 
enum  { ltl::ltl::fm_sri_assign< X, Y >::static_size = 1 }
 

Functions

 ltl::ltl::FMIterConst< T, M, N >::FMIterConst (const FMatrix< T, M, N > &m)
 
ltl::ltl::FMIterConst< T, M, N >::operator[] (const int i) const
 
ltl::ltl::FMIterConst< T, M, N >::operator() (const int i, const int j) const
 
 ltl::ltl::FMIter< T, M, N >::FMIter (FMatrix< T, M, N > &m)
 
ltl::ltl::FMIter< T, M, N >::operator[] (const int i) const
 
T & ltl::ltl::FMIter< T, M, N >::operator[] (const int i)
 
ltl::ltl::FMIter< T, M, N >::operator() (const int i, const int j) const
 
T & ltl::ltl::FMIter< T, M, N >::operator() (const int i, const int j)
 
 ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::FMExprBinopNode (const A &a, const B &b)
 
value_type ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::operator() (const int i, const int j) const
 
value_type ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::operator[] (const int i) const
 
 ltl::ltl::FMExprUnopNode< A, Op, M, N >::FMExprUnopNode (const A &a)
 
value_type ltl::ltl::FMExprUnopNode< A, Op, M, N >::operator() (const int i, const int j) const
 
value_type ltl::ltl::FMExprUnopNode< A, Op, M, N >::operator[] (const int i) const
 
 ltl::ltl::FMExprLiteralNode< T >::FMExprLiteralNode (const T f)
 
const value_type ltl::ltl::FMExprLiteralNode< T >::operator() (const int, const int) const
 
const value_type ltl::ltl::FMExprLiteralNode< T >::operator[] (const int) const
 
 ltl::ltl::FMExprNode< Expr, M, N >::FMExprNode (const A &a)
 
value_type ltl::ltl::FMExprNode< Expr, M, N >::operator() (const int i, const int j) const
 
value_type ltl::ltl::FMExprNode< Expr, M, N >::operator[] (const int i) const
 
static void ltl::ltl::tFMLoop< A, B, operation, M, N >::eval (A &a, const B &b)
 
static void ltl::ltl::tFMSplitLoop< A, B, operation, M, N, true >::eval (A &a, const B &b)
 
static void ltl::ltl::tFMSplitLoop< A, B, operation, M, N, false >::eval (A &a, const B &b)
 
static void ltl::ltl::tMNLoop< A, B, operation, N, I, J >::eval (A &a, const B &b)
 
static void ltl::ltl::tMNLoop< A, B, operation, N, I, 1 >::eval (A &a, const B &b)
 
static void ltl::ltl::tMNLoop< A, B, operation, N, 1, 1 >::eval (A &a, const B &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_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)
 
static bool ltl::ltl::tMBoolLoop< Expr, M, N >::anyof (const Expr &e)
 
static bool ltl::ltl::tMBoolLoop< Expr, M, N >::allof (const Expr &e)
 
static bool ltl::ltl::tMBoolLoop< Expr, M, N >::noneof (const Expr &e)
 
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::anyof (const Expr &e)
 
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::allof (const Expr &e)
 
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::noneof (const Expr &e)
 
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::anyof (const Expr &e)
 
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::allof (const Expr &e)
 
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::noneof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::anyof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::allof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::noneof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::anyof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::allof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::noneof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::anyof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::allof (const Expr &e)
 
static bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::noneof (const Expr &e)
 
 ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::TMatTransposeFMExprOp (const A &a)
 
value_type ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::operator() (const int i, const int j) const
 
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...
 
 ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::TMatVecFVExprOp (const A &a, const B &b)
 
value_type ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::operator[] (const int i) const
 
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)
 
static value_type ltl::ltl::tMatVecLoop< A, B, T, N >::eval (const A &a, const B &b, const int i)
 
static value_type ltl::ltl::tMatVecSplitLoop< A, B, T, N, true >::eval (const A &a, const B &b, const int i)
 
static value_type ltl::ltl::tMatVecSplitLoop< A, B, T, N, false >::eval (const A &a, const B &b, const int i)
 
static value_type ltl::ltl::tNMatVecLoop< A, B, T, N, J >::eval (const A &a, const B &b, const int i)
 
static value_type ltl::ltl::tNMatVecLoop< A, B, T, N, 0 >::eval (const A &a, const B &b, const int i)
 
 ltl::ltl::TMatMatFMExprOp< A, B, T, N >::TMatMatFMExprOp (const A &a, const B &b)
 
value_type ltl::ltl::TMatMatFMExprOp< A, B, T, N >::operator() (const int i, const int j) const
 
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)
 
static value_type ltl::ltl::tMatMatLoop< A, B, T, N >::eval (const A &a, const B &b, const int i, const int j)
 
static value_type ltl::ltl::tMatMatSplitLoop< A, B, T, N, true >::eval (const A &a, const B &b, const int i, const int j)
 
static value_type ltl::ltl::tMatMatSplitLoop< A, B, T, N, false >::eval (const A &a, const B &b, const int i, const int j)
 
static value_type ltl::ltl::tNMatMatLoop< A, B, T, N, K >::eval (const A &a, const B &b, const int i, const int j)
 
static value_type ltl::ltl::tNMatMatLoop< A, B, T, N, 1 >::eval (const A &a, const B &b, const int i, const int j)
 
 ltl::ltl::FMatrix< T, M, N >::FMatrix ()
 default constructor More...
 
 ltl::ltl::FMatrix< T, M, N >::~FMatrix ()
 default destructor More...
 
 ltl::ltl::FMatrix< T, M, N >::FMatrix (const FMatrix< T, M, N > &other)
 copy constructor: copy elements of other. More...
 
 ltl::ltl::FMatrix< T, M, N >::FMatrix (const T *t)
 copy contents of memory pointed to by t. More...
 
 ltl::ltl::FMatrix< T, M, N >::FMatrix (const T t)
 fill with value t. More...
 
template<class Expr >
 ltl::ltl::FMatrix< T, M, N >::FMatrix (const FMExprNode< Expr, M, N > &e)
 construct from expression. More...
 
ListInitializationSwitch
< FMatrix< T, M, N > > 
ltl::ltl::FMatrix< T, M, N >::operator= (T x)
 Initialize with list of values or single value. More...
 
int ltl::ltl::FMatrix< T, M, N >::length () const
 return length of container (M*N). More...
 
int ltl::ltl::FMatrix< T, M, N >::nelements () const
 return length of container (M*N). More...
 
int ltl::ltl::FMatrix< T, M, N >::minIndex (const int) const
 return lowest index of dimension dim. Always 1. More...
 
int ltl::ltl::FMatrix< T, M, N >::maxIndex (const int dim) const
 return highest index of dimension dim. Returns M or N. More...
 
ColumnVector ltl::ltl::FMatrix< T, M, N >::col (const int col)
 Return an ltl::FVector object REFERENCEING the column vector col. More...
 
RowVector ltl::ltl::FMatrix< T, M, N >::row (const int row)
 Return an ltl::FVector object REFERENCEING the row vector row. More...
 
TraceVector ltl::ltl::FMatrix< T, M, N >::traceVector ()
 Return an ltl::FVector object REFERENCEING the trace vector. More...
 
T * ltl::ltl::FMatrix< T, M, N >::data ()
 Return a pointer to the data. More...
 
const T * ltl::ltl::FMatrix< T, M, N >::data () const
 Return a const pointer to the data. More...
 
iterator ltl::ltl::FMatrix< T, M, N >::begin ()
 return an iterator pointing to the first element. More...
 
const_iterator ltl::ltl::FMatrix< T, M, N >::begin () const
 return a const iterator pointing to the first element. More...
 
void ltl::ltl::FMatrix< T, M, N >::fill (const T x)
 fill with value x. More...
 
void ltl::ltl::FMatrix< T, M, N >::swapRows (const int row1, const int row2)
 Swap the values in two row vectors. More...
 
void ltl::ltl::FMatrix< T, M, N >::swapCols (const int col1, const int col2)
 Swap the values in two column vectors. More...
 
static void ltl::ltl::fm_equ_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_plu_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_min_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_mul_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_div_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_mod_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_xor_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_and_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_bor_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_sle_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::fm_sri_assign< X, Y >::eval (X &x, const Y y)
 
static void ltl::ltl::GaussJ< T, N >::getPivot (const FMatrix< T, N, N > &a, FVector< int, N > &ipiv, tNMatPivot< T > &p)
 
static void ltl::ltl::GaussJ< T, N >::swapRows (FMatrix< T, N, N > &a, FVector< T, N > &b, tNMatPivot< T > &p)
 
static void ltl::ltl::GaussJ< T, N >::divByPiv (FMatrix< T, N, N > &a, const tNMatPivot< T > &p)
 
static void ltl::ltl::GaussJ< T, N >::divByPiv (FMatrix< T, N, N > &a, FVector< T, N > &b, const tNMatPivot< T > &p)
 
static void ltl::ltl::GaussJ< T, N >::elimRow (FMatrix< T, N, N > &a, const tNMatPivot< T > &p)
 
static void ltl::ltl::GaussJ< T, N >::elimRow (FMatrix< T, N, N > &a, FVector< T, N > &b, const tNMatPivot< T > &p)
 
static FMatrix< T, N, N > ltl::ltl::GaussJ< T, N >::invert (FMatrix< T, N, N > a)
 invert Matrix, similar to eval() but without solving a linear equation More...
 
static FVector< T, N > ltl::ltl::GaussJ< T, N >::solve (FMatrix< T, N, N > a, FVector< T, N > b)
 Return the solution vector x for the equation A x = b More...
 
static void ltl::ltl::GaussJ< T, N >::eval (FMatrix< T, N, N > &a, FVector< T, N > &b)
 Solve A x = B by Gauss-Jordan elimination. b is replaced by the solution x, A is replaced by its inverse. More...
 
void ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::setData (const ltl::MArray< TDAT, NDIM > &indata, const TDAT in_nan, const ltl::MArray< TDAT, NDIM > &inerror2)
 Set data, error and NaN value. More...
 
void ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::freeData ()
 Free data and error. More...
 
static ltl::FVector< TPAR, NPAR > ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::partofit (const ltl::FVector< TPAR, NPAR > &parameter)
 Convert external fit parameters to internal representation. More...
 
static ltl::FVector< TPAR, NPAR > ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::fittopar (const ltl::FVector< TPAR, NPAR > &fitpar, const typename ltl::FMatrix< TPAR, NPAR, NPAR >::TraceVector &)
 Convert internal fit parameters to external representation. More...
 
static ltl::FVector< TPAR, NPAR > ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::covtoerr (const typename ltl::FMatrix< TPAR, NPAR, NPAR >::TraceVector &trace, const ltl::FVector< TPAR, NPAR > &)
 Calculate external error in parameters from internal covariance matrix. More...
 
TPAR ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::marquardtCoefficients (const ltl::FVector< TPAR, NPAR > &, const TPAR chisquare_limit, ltl::FMatrix< TPAR, NPAR, NPAR > &a, ltl::FVector< TPAR, NPAR > &b) const
 Calculate actual $\chi^2$ (if better than old one) and Hessematrix. More...
 
std::size_t ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::getNdof () const
 Return degrees of freedom for fit. More...
 
 ltl::Gaussian< TPAR, TDAT, 7, 2 >::Gaussian ()
 
static ltl::FVector< TPAR, 7 > ltl::Gaussian< TPAR, TDAT, 7, 2 >::partofit (const ltl::FVector< TPAR, 7 > &parameter)
 
static ltl::FVector< TPAR, 7 > ltl::Gaussian< TPAR, TDAT, 7, 2 >::fittopar (const ltl::FVector< TPAR, 7 > &fitpar, const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &)
 
static ltl::FVector< TPAR, 7 > ltl::Gaussian< TPAR, TDAT, 7, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &trace, const ltl::FVector< TPAR, 7 > &fitpar)
 
static void ltl::Gaussian< TPAR, TDAT, 7, 2 >::fill (const ltl::FVector< TPAR, 7 > &invalue, ltl::MArray< TDAT, 2 > &a)
 
TPAR ltl::Gaussian< TPAR, TDAT, 7, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 7 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 7, 7 > &a, ltl::FVector< TPAR, 7 > &b) const
 
 ltl::Gaussian< TPAR, TDAT, 5, 2 >::Gaussian ()
 
void ltl::Gaussian< TPAR, TDAT, 5, 2 >::setData (const ltl::MArray< TDAT, 2 > &indata, const TDAT in_nan, const ltl::MArray< TDAT, 2 > &inerror2)
 
void ltl::Gaussian< TPAR, TDAT, 5, 2 >::freeData ()
 
static ltl::FVector< TPAR, 5 > ltl::Gaussian< TPAR, TDAT, 5, 2 >::partofit (const ltl::FVector< TPAR, 5 > &parameter)
 
static ltl::FVector< TPAR, 5 > ltl::Gaussian< TPAR, TDAT, 5, 2 >::fittopar (const ltl::FVector< TPAR, 5 > &fitpar, const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &)
 
static ltl::FVector< TPAR, 5 > ltl::Gaussian< TPAR, TDAT, 5, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &trace, const ltl::FVector< TPAR, 5 > &fitpar)
 
static ltl::MArray< TDAT, 2 > & ltl::Gaussian< TPAR, TDAT, 5, 2 >::fill (const ltl::FVector< TPAR, 5 > &invalue, const int x, const int y, ltl::MArray< TDAT, 2 > &a)
 
static ltl::MArray< TDAT, 2 > & ltl::Gaussian< TPAR, TDAT, 5, 2 >::fillExp (const ltl::FVector< TPAR, 5 > &invalue, const int x, const int y, ltl::MArray< TDAT, 2 > &a)
 
TPAR ltl::Gaussian< TPAR, TDAT, 5, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 5 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 5, 5 > &a, ltl::FVector< TPAR, 5 > &b) const
 
 ltl::Gaussian< TPAR, TDAT, 3, 2 >::Gaussian ()
 
void ltl::Gaussian< TPAR, TDAT, 3, 2 >::setData (const ltl::MArray< TDAT, 2 > &indata, const TDAT in_nan, const ltl::MArray< TDAT, 2 > &inerror2)
 
void ltl::Gaussian< TPAR, TDAT, 3, 2 >::freeData ()
 
static ltl::FVector< TPAR, 3 > ltl::Gaussian< TPAR, TDAT, 3, 2 >::partofit (const ltl::FVector< TPAR, 3 > &parameter)
 
static ltl::FVector< TPAR, 3 > ltl::Gaussian< TPAR, TDAT, 3, 2 >::fittopar (const ltl::FVector< TPAR, 3 > &fitpar, const typename ltl::FMatrix< TPAR, 3, 3 >::TraceVector &)
 
static ltl::FVector< TPAR, 3 > ltl::Gaussian< TPAR, TDAT, 3, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 3, 3 >::TraceVector &trace, const ltl::FVector< TPAR, 3 > &fitpar)
 
TPAR ltl::Gaussian< TPAR, TDAT, 3, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 3 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 3, 3 > &a, ltl::FVector< TPAR, 3 > &b) const
 
 ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::PolyGaussian ()
 
static ltl::FVector< TPAR, 7 > ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::partofit (const ltl::FVector< TPAR, 7 > &parameter)
 
static ltl::FVector< TPAR, 7 > ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::fittopar (const ltl::FVector< TPAR, 7 > &fitpar, const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &trace)
 
ltl::FVector< TPAR, 7 > ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &trace, const ltl::FVector< TPAR, 7 > &fitpar)
 
TPAR ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 7 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 7, 7 > &a, ltl::FVector< TPAR, 7 > &b) const
 
 ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::PolyGaussian ()
 
void ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::setData (const ltl::MArray< TDAT, 2 > &indata, const TDAT in_nan, const ltl::MArray< TDAT, 2 > &inerror2)
 
void ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::freeData ()
 
static ltl::FVector< TPAR, 5 > ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::partofit (const ltl::FVector< TPAR, 5 > &parameter)
 
static ltl::FVector< TPAR, 5 > ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::fittopar (const ltl::FVector< TPAR, 5 > &fitpar, const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &trace)
 
ltl::FVector< TPAR, 5 > ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &trace, const ltl::FVector< TPAR, 5 > &fitpar)
 
static ltl::MArray< TDAT, 2 > & ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::fill (const ltl::FVector< TPAR, 5 > &invalue, const int x, const int y, ltl::MArray< TDAT, 2 > &a)
 
static ltl::MArray< TDAT, 2 > & ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::fillExp (const ltl::FVector< TPAR, 5 > &invalue, const int x, const int y, ltl::MArray< TDAT, 2 > &a)
 
TPAR ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 5 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 5, 5 > &a, ltl::FVector< TPAR, 5 > &b) const
 
 ltl::Moffat< TPAR, TDAT, 10, 2 >::Moffat ()
 
static void ltl::Moffat< TPAR, TDAT, 10, 2 >::fill (const ltl::FVector< TPAR, 10 > &invalue, ltl::MArray< TDAT, 2 > &a)
 
TPAR ltl::Moffat< TPAR, TDAT, 10, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 10 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 10, 10 > &a, ltl::FVector< TPAR, 10 > &b) const
 
 ltl::Moffat< TPAR, TDAT, 8, 2 >::Moffat ()
 
static void ltl::Moffat< TPAR, TDAT, 8, 2 >::fill (const ltl::FVector< TPAR, 8 > &invalue, ltl::MArray< TDAT, 2 > &a)
 
TPAR ltl::Moffat< TPAR, TDAT, 8, 2 >::marquardtCoefficients (const ltl::FVector< TPAR, 8 > &parameter, const TPAR chisquare_limit, ltl::FMatrix< TPAR, 8, 8 > &a, ltl::FVector< TPAR, 8 > &b) const
 
static ltl::FVector< TPAR, 10 > ltl::DegMoffat< TPAR, TDAT, 10, 2 >::partofit (const ltl::FVector< TPAR, 10 > &parameter)
 
static ltl::FVector< TPAR, 10 > ltl::DegMoffat< TPAR, TDAT, 10, 2 >::fittopar (const ltl::FVector< TPAR, 10 > &fitpar, const typename ltl::FMatrix< TPAR, 10, 10 >::TraceVector &)
 
ltl::FVector< TPAR, 10 > ltl::DegMoffat< TPAR, TDAT, 10, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 10, 10 >::TraceVector &trace, const ltl::FVector< TPAR, 10 > &)
 
static void ltl::DegMoffat< TPAR, TDAT, 8, 2 >::fill (const ltl::FVector< TPAR, 8 > &invalue, ltl::MArray< TDAT, 2 > &a)
 
static ltl::FVector< TPAR, 8 > ltl::DegMoffat< TPAR, TDAT, 8, 2 >::partofit (const ltl::FVector< TPAR, 8 > &parameter)
 
static ltl::FVector< TPAR, 8 > ltl::DegMoffat< TPAR, TDAT, 8, 2 >::fittopar (const ltl::FVector< TPAR, 8 > &fitpar, const typename ltl::FMatrix< TPAR, 8, 8 >::TraceVector &)
 
ltl::FVector< TPAR, 8 > ltl::DegMoffat< TPAR, TDAT, 8, 2 >::covtoerr (const typename ltl::FMatrix< TPAR, 8, 8 >::TraceVector &trace, const ltl::FVector< TPAR, 8 > &)
 
 ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::Marquardt (const std::size_t initer, const TPAR ainstart, const TPAR ainstep, const TPAR ainmin, const TPAR ainmax, const FVector< bool, NPAR > ignin=false)
 Construct class with fit constraints. More...
 
void ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::eval (const MArray< TDAT, NDIM > &data, const TDAT nan, const MArray< TDAT, NDIM > &error2, const FVector< TPAR, NPAR > &inpar)
 Fit to data and $error^2$ ignoring nan, start with inpar. More...
 
FVector< TPAR, NPAR > ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getResult ()
 Return result vector. More...
 
TPAR ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getChiSquare () const
 Return final $\chi^2$. More...
 
std::size_t ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getNIteration () const
 Return No needed iterations. More...
 
FVector< TPAR, NPAR > ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getVariance ()
 Return $error^2$ in fit parameters. More...
 
template<typename Expr >
 ltl::ltl::MArray< T, D >::MArray (const ExprNode< Expr, N > &e, const bool map=false, const char *filename=NULL)
 Construct from an array-valued expression. More...
 
 ltl::ltl::MArray< T, D >::MArray (const Shape< N > *s, const bool map=false, const char *filename=NULL)
 Construct from shape. More...
 
void ltl::ltl::MArray< T, D >::makeReference (const MArray< T, N > &other)
 Make this being a referece to other's data. More...
 
template<int N2>
void ltl::ltl::MArray< T, D >::makeReferenceWithDims (const MArray< T, N2 > &other, const int *dims)
 Make a reference as a different-dimensional view of another MArray's data. More...
 
void ltl::ltl::MArray< T, D >::realloc (const Shape< N > &s, const bool map=false, const char *filename=NULL)
 Reallocate memory. Data are abolished. More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator= (const ExprNode< Expr, N > &e)
 Assignment of an expression to a MArray. More...
 
void ltl::ltl::MArray< T, D >::describeSelf () const
 Debug output. Print geometry information. More...
 
template<typename T2 >
void ltl::ltl::MArray< T, D >::copy (const MArray< T2, N > &other)
 Copy from other. More...
 
void ltl::ltl::MArray< T, D >::fill (const T t)
 Fill with t. More...
 
void ltl::ltl::MArray< T, D >::setupMemory (const bool map=false, const char *filename=NULL)
 
void ltl::ltl::MArray< T, D >::setupShape (const int *dims)
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1)
 Constructs a pure subarray of other, i.e. rank is preserved. More...
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2)
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3)
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4)
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4, const Range &r5)
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4, const Range &r5, const Range &r6)
 
void ltl::ltl::MArray< T, D >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4, const Range &r5, const Range &r6, const Range &r7)
 
void ltl::ltl::MArray< T, D >::setrange (const int dim, const Range &r)
 
template<int N2, typename R1 , typename R2 , typename R3 , typename R4 , typename R5 , typename R6 , typename R7 >
void ltl::ltl::MArray< T, D >::slicearray (const MArray< T, N2 > &other, R1 r1, R2 r2, R3 r3, R4 r4, R5 r5, R6 r6, R7 r7)
 
template<int N2>
void ltl::ltl::MArray< T, D >::slice (int &setRank, Range r, const MArray< T, N2 > &other, int sourceRank)
 ltl::Range version of slice(): Essentially a subarray in this dimension. More...
 
template<int N2>
void ltl::ltl::MArray< T, D >::slice (int &setRank, int r, const MArray< T, N2 > &other, int sourceRank)
 int version of slice(): slice in this dimension, rank is reduced by one. More...
 
template<class T , int M, int N>
std::ostream & operator<< (std::ostream &os, const FMatrix< T, M, N > &A)
 
template<class T , int M, int N>
std::istream & operator>> (std::istream &is, FMatrix< T, M, N > &A)
 

Variables

T * ltl::ltl::FMIterConst< T, M, N >::__data_
 
T * ltl::ltl::FMIter< T, M, N >::__data_
 
ltl::ltl::FMatrix< T, M, N >::__data_ [M *N]
 Storage for the matrix elements. More...
 
ltl::MArray< TDAT, NDIM > ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::data_
 
TDAT ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::nan_data_
 
ltl::MArray< TDAT, NDIM > ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::error2_
 
int ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::ndof_
 

Friends

class ltl::ltl::FMatrix< T, M, N >::FMIter< T, M, N >
 
class ltl::ltl::FMatrix< T, M, N >::FMIterConst< T, M, N >
 
class ltl::ltl::FMatrix< T, M, N >::ListInitializationSwitch< FMatrix< T, M, N > >
 

Construct from preexisting data.

The array dims[] holds the lengths of each dimension (The number of dimensions, and hence the length of dims[] is known from the template parameter N.) No checking is performed. The index ranges are {1..dims[i]} along each dimension i.

 ltl::ltl::MArray< T, D >::MArray (T *data, const int *dims)
 Construct from allocated memory. Note that this memory will be freed when the MArray is destructed. More...
 
 ltl::ltl::MArray< T, D >::MArray (const std::string filename, const int *dims)
 Construct from map file. More...
 

Overloaded X= operators. There is a version for an

MArray

rhs, an expression rhs, and a literal rhs for each operator. To have a single implementation of mathematical operations for scalar and vectorized code (where the C language extensions do not define X= ), we transform the

A x= E

assignment into

A = A x E

and call

operator=

.

template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator+= (const MArray< T2, N > &a)
 operator+= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator+= (const ExprNode< Expr, N > &e)
 operator+= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator+= (const T a)
 operator+= More...
 
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator-= (const MArray< T2, N > &a)
 operator-= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator-= (const ExprNode< Expr, N > &e)
 operator-= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator-= (const T a)
 operator-= More...
 
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator*= (const MArray< T2, N > &a)
 operator*= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator*= (const ExprNode< Expr, N > &e)
 operator*= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator*= (const T a)
 operator*= More...
 
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator/= (const MArray< T2, N > &a)
 operator/= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator/= (const ExprNode< Expr, N > &e)
 operator/= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator/= (const T a)
 operator/= More...
 
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator|= (const MArray< T2, N > &a)
 operator|= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator|= (const ExprNode< Expr, N > &e)
 operator|= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator|= (const T a)
 operator|= More...
 
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator&= (const MArray< T2, N > &a)
 operator&= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator&= (const ExprNode< Expr, N > &e)
 operator&= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator&= (const T a)
 operator&= More...
 
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator^= (const MArray< T2, N > &a)
 operator^= More...
 
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, D >::operator^= (const ExprNode< Expr, N > &e)
 operator^= More...
 
MArray< T, N > & ltl::ltl::MArray< T, D >::operator^= (const T a)
 operator^= More...
 

Change bases:

Change the bases of the array (the bases are the first indices of each dimension)

void ltl::ltl::MArray< T, D >::setBase (const int b1)
 
void ltl::ltl::MArray< T, D >::setBase (const int b1, const int b2)
 
void ltl::ltl::MArray< T, D >::setBase (const int b1, const int b2, const int b3)
 
void ltl::ltl::MArray< T, D >::setBase (const int b1, const int b2, const int b3, const int b4)
 
void ltl::ltl::MArray< T, D >::setBase (const int b1, const int b2, const int b3, const int b4, const int b5)
 
void ltl::ltl::MArray< T, D >::setBase (const int b1, const int b2, const int b3, const int b4, const int b5, const int b6)
 
void ltl::ltl::MArray< T, D >::setBase (const int b1, const int b2, const int b3, const int b4, const int b5, const int b6, const int b7)
 

Reverse and Transpose:

Reorder array (without copy). Very fast!

void ltl::ltl::MArray< T, D >::reverseSelf (const int dim=1)
 Reverse this MArray. More...
 
MArray< T, N > ltl::ltl::MArray< T, D >::reverse (const int dim=1) const
 Return reversed MArray. More...
 
void ltl::ltl::MArray< T, D >::transposeSelf (const int dim1=1, const int dim2=2)
 Transpose this MArray. More...
 
MArray< T, N > ltl::ltl::MArray< T, D >::transpose (const int dim1=1, const int dim2=2) const
 Return transposed MArray. More...
 
typedef T ltl::ltl::FMatrix< T, M, N >::value_type
 STL-compatible type definitions. More...
 
typedef FMIter< T, M, N > ltl::ltl::FMatrix< T, M, N >::iterator
 
typedef FMIterConst< T, M, N > ltl::ltl::FMatrix< T, M, N >::const_iterator
 
typedef T & ltl::ltl::FMatrix< T, M, N >::reference
 
typedef const T & ltl::ltl::FMatrix< T, M, N >::const_reference
 
typedef std::size_t ltl::ltl::FMatrix< T, M, N >::size_type
 
typedef std::ptrdiff_t ltl::ltl::FMatrix< T, M, N >::difference_type
 
typedef FVector< T, M, N > ltl::ltl::FMatrix< T, M, N >::ColumnVector
 
typedef FVector< T, N, 1 > ltl::ltl::FMatrix< T, M, N >::RowVector
 
typedef FVector< T, M, N+1 > ltl::ltl::FMatrix< T, M, N >::TraceVector
 
static size_type ltl::ltl::FMatrix< T, M, N >::size ()
 STL return M*N. More...
 
static bool ltl::ltl::FMatrix< T, M, N >::empty ()
 STL empty(). Always false. More...
 
static size_type ltl::ltl::FMatrix< T, M, N >::max_size ()
 STL: Maximum capacity. Always ==size() More...
 
ltl::ltl::FMatrix< T, M, N >::operator() (const int i, const int j) const
 1-based access to elements. More...
 
T & ltl::ltl::FMatrix< T, M, N >::operator() (const int i, const int j)
 1-based access to elements. More...
 
ltl::ltl::FMatrix< T, M, N >::operator[] (const int i) const
 Direct zero-based access to the (linear) block of memory. More...
 
T & ltl::ltl::FMatrix< T, M, N >::operator[] (const int i)
 Direct zero-based access to the (linear) block of memory. More...
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator= (const FMExprNode< Expr, M, N > &e)
 operatorX= for expression rhs. More...
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator+= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator-= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator*= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator/= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator%= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator^= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator&= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator|= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator<<= (const FMExprNode< Expr, M, N > &e)
 
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator>>= (const FMExprNode< Expr, M, N > &e)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator= (const FMatrix< T2, M, N > &v)
 operatorX for FMatrix rhs. More...
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator= (const FMatrix< T, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator+= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator-= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator*= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator/= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator%= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator^= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator&= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator|= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator<<= (const FMatrix< T2, M, N > &v)
 
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator>>= (const FMatrix< T2, M, N > &v)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator+= (const T t)
 operatorX= for scalar rhs. More...
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator-= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator*= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator/= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator%= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator^= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator&= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator|= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator<<= (const T t)
 
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator>>= (const T t)
 

Detailed Description

Macro Definition Documentation

#define FMBINOP_AA (   operator,
  op 
)
Value:
template<class T1, class T2, int M, int N> \
inline FMExprNode<FMExprBinopNode<typename FMatrix<T1,M,N>::const_iterator, \
typename FMatrix<T2,M,N>::const_iterator, \
op<T1,T2>, M, N>, M, N > \
operator( const FMatrix<T1,M,N>& a, const FMatrix<T2,M,N>& b ) \
{ \
typedef FMExprBinopNode<typename FMatrix<T1,M,N>::const_iterator, \
typename FMatrix<T2,M,N>::const_iterator, \
op<T1,T2>, M, N > \
ExprT; \
return FMExprNode<ExprT,M,N>( ExprT(a.begin(), b.begin()) ); \
}
#define FMBINOP_EA (   operator,
  op 
)
Value:
template<class A, class T, int M, int N> \
inline FMExprNode<FMExprBinopNode<FMExprNode<A,M,N>, \
typename FMatrix<T,M,N>::const_iterator, \
op <typename A::value_type,T>, M,N >, M,N > \
operator( const FMExprNode<A,M,N>& a, const FMatrix<T,M,N>& b) \
{ \
typedef FMExprBinopNode<FMExprNode<A,M,N>, \
typename FMatrix<T,M,N>::const_iterator, \
op <typename A::value_type,T>, M, N > \
ExprT; \
return FMExprNode<ExprT,M,N>( ExprT(a, b.begin()) ); \
}
#define FMBINOP_AE (   operator,
  op 
)
Value:
template<class A, class T, int M, int N> \
inline FMExprNode<FMExprBinopNode<typename FMatrix<T,M,N>::const_iterator, \
FMExprNode<A,M,N>, \
op <T,typename A::value_type>,M,N >,M,N > \
operator( const FMatrix<T,M,N>& a, const FMExprNode<A,M,N>& b ) \
{ \
typedef FMExprBinopNode<typename FMatrix<T,M,N>::const_iterator, \
FMExprNode<A,M,N>, \
op <T,typename A::value_type>,M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>( ExprT( a.begin(), b) ); \
}
#define FMBINOP_EE (   operator,
  op 
)
Value:
template<class A, class B, int M, int N> \
inline FMExprNode<FMExprBinopNode<FMExprNode<A,M,N>, \
FMExprNode<B,M,N>, \
op <typename A::value_type, typename B::value_type>, \
M,N >, M,N > \
operator( const FMExprNode<A,M,N>& a, const FMExprNode<B,M,N>& b ) \
{ \
typedef FMExprBinopNode<FMExprNode<A,M,N>, \
FMExprNode<B,M,N>, \
op <typename A::value_type, typename B::value_type>, M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>(ExprT(a,b)); \
}
#define FMBINOP_AL (   operator,
  op 
)
Value:
template<class T, int M, int N> \
inline FMExprNode<FMExprBinopNode<typename FMatrix<T,M,N>::const_iterator, \
FMExprLiteralNode<typename FMatrix<T,M,N>::value_type>, \
op <T,T>, M,N >, M,N > \
operator( const FMatrix<T,M,N>& a, const typename FMatrix<T,M,N>::value_type& b ) \
{ \
typedef FMExprBinopNode<typename FMatrix<T,M,N>::const_iterator, \
FMExprLiteralNode<T>, \
op <T,T>, M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>( ExprT(a.begin(),b) ); \
}
#define FMBINOP_EL (   operator,
  op 
)
Value:
template<class T, int M, int N> \
inline FMExprNode<FMExprBinopNode<FMExprNode<T,M,N>, \
FMExprLiteralNode<typename T::value_type>, \
op <typename T::value_type, typename T::value_type>,M,N >,M,N > \
operator( const FMExprNode<T,M,N>& a, const typename T::value_type& b ) \
{ \
typedef FMExprBinopNode<FMExprNode<T,M,N>, \
FMExprLiteralNode<typename T::value_type>, \
op <typename T::value_type, typename T::value_type>, M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>(ExprT(a,b)); \
}
#define FMBINOP_LA (   operator,
  op 
)
Value:
template<class T, int M, int N> \
inline FMExprNode<FMExprBinopNode<FMExprLiteralNode<typename FMatrix<T,M,N>::value_type>, \
typename FMatrix<T,M,N>::const_iterator, \
op <T, T>, M,N >, M,N > \
operator( const typename FMatrix<T,M,N>::value_type& a, const FMatrix<T,M,N>& b ) \
{ \
typedef FMExprBinopNode<FMExprLiteralNode<T>, \
typename FMatrix<T,M,N>::const_iterator, \
op <T, T>, M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>(ExprT(a, b.begin())); \
}
#define FMBINOP_LE (   operator,
  op 
)
Value:
template<class T, int M, int N> \
inline FMExprNode<FMExprBinopNode<FMExprLiteralNode<typename T::value_type>, \
FMExprNode<T,M,N>, \
op <typename T::value_type, typename T::value_type>,M,N >,M,N > \
operator( const typename T::value_type& a, const FMExprNode<T,M,N>& b ) \
{ \
typedef FMExprBinopNode<FMExprLiteralNode<typename T::value_type>, \
FMExprNode<T,M,N>, \
op <typename T::value_type, typename T::value_type>,M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>(ExprT(a,b)); \
}
#define FMUNOP_A (   operator,
  op 
)
Value:
template<class T, int M, int N> \
inline FMExprNode<FMExprUnopNode<typename FMatrix<T,M,N>::const_iterator, \
op <T>, M,N >, M,N > \
operator( const FMatrix<T,M,N>& a ) \
{ \
typedef FMExprUnopNode<typename FMatrix<T,M,N>::const_iterator, \
op <T>, M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>(ExprT(a.begin())); \
}
#define FMUNOP_E (   operator,
  op 
)
Value:
template<class A, int M, int N> \
inline FMExprNode<FMExprUnopNode<FMExprNode<A,M,N>, \
op <typename A::value_type>, M,N >, M,N > \
operator( const FMExprNode<A,M,N>& a ) \
{ \
typedef FMExprUnopNode<FMExprNode<A,M,N>, op <typename A::value_type>,M,N > \
ExprT; \
return FMExprNode<ExprT,M,N>(ExprT(a)); \
}
#define DECLARE_FMBINOP (   operation,
  opname 
)
Value:
FMBINOP_AA(operator operation,__ltl_##opname) \
FMBINOP_AE(operator operation,__ltl_##opname) \
FMBINOP_EA(operator operation,__ltl_##opname) \
FMBINOP_EE(operator operation,__ltl_##opname) \
FMBINOP_AL(operator operation,__ltl_##opname) \
FMBINOP_EL(operator operation,__ltl_##opname) \
FMBINOP_LA(operator operation,__ltl_##opname) \
FMBINOP_LE(operator operation,__ltl_##opname)
#define FMBINOP_LE(operator, op)
Definition: marquardt.h:320
#define FMBINOP_AA(operator, op)
Definition: marquardt.h:213
#define FMBINOP_EA(operator, op)
Definition: marquardt.h:229
#define FMBINOP_AE(operator, op)
Definition: marquardt.h:244
#define FMBINOP_AL(operator, op)
Definition: marquardt.h:275
#define FMBINOP_EE(operator, op)
Definition: marquardt.h:259
#define FMBINOP_EL(operator, op)
Definition: marquardt.h:290
#define FMBINOP_LA(operator, op)
Definition: marquardt.h:305
#define DECLARE_FMUNOP (   operation,
  opname 
)
Value:
FMUNOP_A(operator operation,__ltl_##opname) \
FMUNOP_E(operator operation,__ltl_##opname)
#define FMUNOP_A(operator, op)
Definition: marquardt.h:344
#define FMUNOP_E(operator, op)
Definition: marquardt.h:358
#define DECLARE_FMBINARY_FUNC_ (   function)
Value:
FMBINOP_AA(function,__ltl_##function) \
FMBINOP_AE(function,__ltl_##function) \
FMBINOP_EA(function,__ltl_##function) \
FMBINOP_EE(function,__ltl_##function) \
FMBINOP_AL(function,__ltl_##function) \
FMBINOP_EL(function,__ltl_##function) \
FMBINOP_LA(function,__ltl_##function) \
FMBINOP_LE(function,__ltl_##function)
#define FMBINOP_LE(operator, op)
Definition: marquardt.h:320
#define FMBINOP_AA(operator, op)
Definition: marquardt.h:213
#define FMBINOP_EA(operator, op)
Definition: marquardt.h:229
#define FMBINOP_AE(operator, op)
Definition: marquardt.h:244
#define FMBINOP_AL(operator, op)
Definition: marquardt.h:275
#define FMBINOP_EE(operator, op)
Definition: marquardt.h:259
#define FMBINOP_EL(operator, op)
Definition: marquardt.h:290
#define FMBINOP_LA(operator, op)
Definition: marquardt.h:305
#define DECLARE_FMUNARY_FUNC_ (   function)
Value:
FMUNOP_A(function,__ltl_##function) \
FMUNOP_E(function,__ltl_##function)
#define FMUNOP_A(operator, op)
Definition: marquardt.h:344
#define FMUNOP_E(operator, op)
Definition: marquardt.h:358
#define DECLARE_FM_BINARY_FUNC (   function,
  ret_type 
)
Value:
MAKE_BINAP_FUNC( __ltl_##function, ret_type, function ) \
#define MAKE_BINAP_FUNC(classname, ret_type, func)
#define DECLARE_FMBINARY_FUNC_(function)
Definition: marquardt.h:401
#define DECLARE_FM_UNARY_FUNC (   function,
  ret_type 
)
Value:
MAKE_UNAP_FUNC( __ltl_##function, ret_type, function ) \
#define MAKE_UNAP_FUNC(classname, ret_type, op)
#define DECLARE_FMUNARY_FUNC_(function)
Definition: marquardt.h:415
#define MAKE_ASSIGNFM_OP (   name,
  op 
)
Value:
template<class X, class Y> \
class name : public _assignfm_base \
{ \
public: \
typedef X value_type; \
enum { static_size = 1 }; \
static inline void eval( X& restrict_ x, const Y y ) \
{ x op (X)y; } \
};
#define restrict_
#define MAKE_FMEXPR_ASSIGNMENT_OP (   op,
  name 
)
Value:
template<class T, int M, int N> \
template<class Expr> \
inline FMatrix<T,M,N>& \
FMatrix<T,M,N>::operator op( const FMExprNode<Expr,M,N>& e ) \
{ \
tFMLoop< FMatrix<T,M,N>, FMExprNode<Expr,M,N>, \
name<T, typename Expr::value_type>, \
M, N >::eval( *this, e ); \
return *this; \
}
#define MAKE_FMM_ASSIGNMENT_OP (   op,
  name 
)
Value:
template<class T, int M, int N> \
template<class T2> \
inline FMatrix<T,M,N>& \
FMatrix<T,M,N>::operator op( const FMatrix<T2,M,N>& restrict_ e ) \
{ \
tFMLoop< FMatrix<T,M,N>, \
typename FMatrix<T2,M,N>::const_iterator, \
name<T, T2>, \
M, N >::eval( *this, e ); \
return *this; \
}
#define restrict_
#define MAKE_FMLITERAL_ASSIGNEMNT_OP (   op,
  name 
)
Value:
template<class T, int M, int N> \
inline FMatrix<T,M,N>& \
FMatrix<T,M,N>::operator op( const T t ) \
{ \
FMExprNode<FMExprLiteralNode<T>,M,N> e(t); \
\
tFMLoop< FMatrix<T,M,N>, \
FMExprNode<FMExprLiteralNode<T>,M,N>, \
name<T,T>, M, N >::eval( *this, e ); \
return *this; \
}

Typedef Documentation

template<class A , class B , class Op , int M, int N>
typedef Op::value_type ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::value_type
template<class A , class Op , int M, int N>
typedef Op::value_type ltl::ltl::FMExprUnopNode< A, Op, M, N >::value_type
template<class T >
typedef T ltl::ltl::FMExprLiteralNode< T >::value_type
template<class Expr , int M, int N>
typedef A::value_type ltl::ltl::FMExprNode< Expr, M, N >::value_type
template<class T >
typedef FMExprLiteralNode<T> ltl::ltl::asFMExpr< T >::value_type
template<class T , int M, int N>
typedef FMExprNode<T,M,N> ltl::ltl::asFMExpr< FMExprNode< T, M, N > >::value_type
template<class T , int M, int N>
typedef FMatrix<T,M,N>::const_iterator ltl::ltl::asFMExpr< FMatrix< T, M, N > >::value_type
template<class A , class B , class operation , int M, int N>
typedef operation::value_type ltl::ltl::tFMLoop< A, B, operation, M, N >::value_type
template<class A , class B , class operation , int M, int N>
typedef operation::value_type ltl::ltl::tFMSplitLoop< A, B, operation, M, N, true >::value_type
template<class A , class B , class operation , int M, int N>
typedef operation::value_type ltl::ltl::tFMSplitLoop< A, B, operation, M, N, false >::value_type
template<class A , class B , class operation , int N, int I, int J>
typedef operation::value_type ltl::ltl::tMNLoop< A, B, operation, N, I, J >::value_type
template<class Expr , int M, int N>
typedef bool ltl::ltl::tMBoolLoop< Expr, M, N >::value_type
template<class Expr , int M, int N>
typedef bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::value_type
template<class Expr , int M, int N>
typedef bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::value_type
template<class Expr , int N, int I, int J>
typedef bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::value_type
template<class Expr , int N, int I>
typedef bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::value_type
template<class Expr , int N>
typedef bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::value_type
template<class A , class T , int M, int N>
typedef T ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::value_type
template<class A , class B , class T , int M, int N>
typedef T ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tMatVecLoop< A, B, T, N >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tMatVecSplitLoop< A, B, T, N, true >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tMatVecSplitLoop< A, B, T, N, false >::value_type
template<class A , class B , class T , int N, int J>
typedef T ltl::ltl::tNMatVecLoop< A, B, T, N, J >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tNMatVecLoop< A, B, T, N, 0 >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::TMatMatFMExprOp< A, B, T, N >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tMatMatLoop< A, B, T, N >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tMatMatSplitLoop< A, B, T, N, true >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tMatMatSplitLoop< A, B, T, N, false >::value_type
template<class A , class B , class T , int N, int K>
typedef T ltl::ltl::tNMatMatLoop< A, B, T, N, K >::value_type
template<class A , class B , class T , int N>
typedef T ltl::ltl::tNMatMatLoop< A, B, T, N, 1 >::value_type
template<class T, int M, int N>
typedef T ltl::ltl::FMatrix< T, M, N >::value_type

STL-compatible type definitions.

template<class T, int M, int N>
typedef FMIter<T,M,N> ltl::ltl::FMatrix< T, M, N >::iterator
template<class T, int M, int N>
typedef FMIterConst<T,M,N> ltl::ltl::FMatrix< T, M, N >::const_iterator
template<class T, int M, int N>
typedef T& ltl::ltl::FMatrix< T, M, N >::reference
template<class T, int M, int N>
typedef const T& ltl::ltl::FMatrix< T, M, N >::const_reference
template<class T, int M, int N>
typedef std::size_t ltl::ltl::FMatrix< T, M, N >::size_type
template<class T, int M, int N>
typedef std::ptrdiff_t ltl::ltl::FMatrix< T, M, N >::difference_type
template<class T, int M, int N>
typedef FVector<T,M,N> ltl::ltl::FMatrix< T, M, N >::ColumnVector
template<class T, int M, int N>
typedef FVector<T,N,1> ltl::ltl::FMatrix< T, M, N >::RowVector
template<class T, int M, int N>
typedef FVector<T,M,N+1> ltl::ltl::FMatrix< T, M, N >::TraceVector
template<class X , class Y >
typedef X ltl::ltl::fm_equ_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_plu_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_min_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_mul_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_div_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_mod_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_xor_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_and_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_bor_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_sle_assign< X, Y >::value_type
template<class X , class Y >
typedef X ltl::ltl::fm_sri_assign< X, Y >::value_type

Enumeration Type Documentation

template<class T , int M, int N>
anonymous enum
Enumerator
static_size 
template<class T , int M, int N>
anonymous enum
Enumerator
static_size 
template<class A , class B , class Op , int M, int N>
anonymous enum
Enumerator
static_size 
template<class A , class Op , int M, int N>
anonymous enum
Enumerator
static_size 
template<class T >
anonymous enum
Enumerator
static_size 
template<class Expr , int M, int N>
anonymous enum
Enumerator
static_size 
template<class A , class B , class operation , int M, int N>
anonymous enum
Enumerator
static_size 
template<class Expr , int M, int N>
anonymous enum
Enumerator
static_size 
template<class A , class T , int M, int N>
anonymous enum
Enumerator
static_size 
template<class A , class B , class T , int M, int N>
anonymous enum
Enumerator
static_size 
template<class A , class B , class T , int N>
anonymous enum
Enumerator
static_size 
template<class A , class B , class T , int N>
anonymous enum
Enumerator
static_size 
template<class A , class B , class T , int N>
anonymous enum
Enumerator
static_size 
template<class T, int M, int N>
anonymous enum

Used by expression engine to decide which loops to unroll.

Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 
template<class X , class Y >
anonymous enum
Enumerator
static_size 

Function Documentation

template<class T , int M, int N>
ltl::ltl::FMIterConst< T, M, N >::FMIterConst ( const FMatrix< T, M, N > &  m)
inline
template<class T , int M, int N>
T ltl::ltl::FMIterConst< T, M, N >::operator[] ( const int  i) const
inline
template<class T , int M, int N>
T ltl::ltl::FMIterConst< T, M, N >::operator() ( const int  i,
const int  j 
) const
inline
template<class T , int M, int N>
ltl::ltl::FMIter< T, M, N >::FMIter ( FMatrix< T, M, N > &  m)
inline
template<class T , int M, int N>
T ltl::ltl::FMIter< T, M, N >::operator[] ( const int  i) const
inline
template<class T , int M, int N>
T& ltl::ltl::FMIter< T, M, N >::operator[] ( const int  i)
inline
template<class T , int M, int N>
T ltl::ltl::FMIter< T, M, N >::operator() ( const int  i,
const int  j 
) const
inline
template<class T , int M, int N>
T& ltl::ltl::FMIter< T, M, N >::operator() ( const int  i,
const int  j 
)
inline
template<class A , class B , class Op , int M, int N>
ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::FMExprBinopNode ( const A &  a,
const B &  b 
)
inline
template<class A , class B , class Op , int M, int N>
value_type ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::operator() ( const int  i,
const int  j 
) const
inline
template<class A , class B , class Op , int M, int N>
value_type ltl::ltl::FMExprBinopNode< A, B, Op, M, N >::operator[] ( const int  i) const
inline
template<class A , class Op , int M, int N>
ltl::ltl::FMExprUnopNode< A, Op, M, N >::FMExprUnopNode ( const A &  a)
inline
template<class A , class Op , int M, int N>
value_type ltl::ltl::FMExprUnopNode< A, Op, M, N >::operator() ( const int  i,
const int  j 
) const
inline
template<class A , class Op , int M, int N>
value_type ltl::ltl::FMExprUnopNode< A, Op, M, N >::operator[] ( const int  i) const
inline
template<class T >
ltl::ltl::FMExprLiteralNode< T >::FMExprLiteralNode ( const T  f)
inline
template<class T >
const value_type ltl::ltl::FMExprLiteralNode< T >::operator() ( const int  ,
const int   
) const
inline
template<class T >
const value_type ltl::ltl::FMExprLiteralNode< T >::operator[] ( const int  ) const
inline
template<class Expr , int M, int N>
ltl::ltl::FMExprNode< Expr, M, N >::FMExprNode ( const A &  a)
inline
template<class Expr , int M, int N>
value_type ltl::ltl::FMExprNode< Expr, M, N >::operator() ( const int  i,
const int  j 
) const
inline
template<class Expr , int M, int N>
value_type ltl::ltl::FMExprNode< Expr, M, N >::operator[] ( const int  i) const
inline
template<class A , class B , class operation , int M, int N>
static void ltl::ltl::tFMLoop< A, B, operation, M, N >::eval ( A &  a,
const B &  b 
)
inlinestatic
template<class A , class B , class operation , int M, int N>
static void ltl::ltl::tFMSplitLoop< A, B, operation, M, N, true >::eval ( A &  a,
const B &  b 
)
inlinestatic
template<class A , class B , class operation , int M, int N>
static void ltl::ltl::tFMSplitLoop< A, B, operation, M, N, false >::eval ( A &  a,
const B &  b 
)
inlinestatic
template<class A , class B , class operation , int N, int I, int J>
static void ltl::ltl::tMNLoop< A, B, operation, N, I, J >::eval ( A &  a,
const B &  b 
)
inlinestatic
template<class A , class B , class operation , int N, int I>
static void ltl::ltl::tMNLoop< A, B, operation, N, I, 1 >::eval ( A &  a,
const B &  b 
)
inlinestatic
template<class A , class B , class operation , int N>
static void ltl::ltl::tMNLoop< A, B, operation, N, 1, 1 >::eval ( A &  a,
const B &  b 
)
inlinestatic
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
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)
inline
template<class Expr , int M, int N>
bool ltl::ltl::anyof ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
bool ltl::ltl::anyof ( FMatrix< T, M, N > &  e)
inline
template<class Expr , int M, int N>
bool ltl::ltl::allof ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
bool ltl::ltl::allof ( FMatrix< T, M, N > &  e)
inline
template<class Expr , int M, int N>
bool ltl::ltl::noneof ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
bool ltl::ltl::noneof ( FMatrix< T, M, N > &  e)
inline
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolLoop< Expr, M, N >::anyof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolLoop< Expr, M, N >::allof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolLoop< Expr, M, N >::noneof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::anyof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::allof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, true >::noneof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::anyof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::allof ( const Expr &  e)
inlinestatic
template<class Expr , int M, int N>
static bool ltl::ltl::tMBoolSplitLoop< Expr, M, N, false >::noneof ( const Expr &  e)
inlinestatic
template<class Expr , int N, int I, int J>
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::anyof ( const Expr &  e)
inlinestatic
template<class Expr , int N, int I, int J>
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::allof ( const Expr &  e)
inlinestatic
template<class Expr , int N, int I, int J>
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, J >::noneof ( const Expr &  e)
inlinestatic
template<class Expr , int N, int I>
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::anyof ( const Expr &  e)
inlinestatic
template<class Expr , int N, int I>
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::allof ( const Expr &  e)
inlinestatic
template<class Expr , int N, int I>
static bool ltl::ltl::tMNBoolLoop< Expr, N, I, 1 >::noneof ( const Expr &  e)
inlinestatic
template<class Expr , int N>
static bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::anyof ( const Expr &  e)
inlinestatic
template<class Expr , int N>
static bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::allof ( const Expr &  e)
inlinestatic
template<class Expr , int N>
static bool ltl::ltl::tMNBoolLoop< Expr, N, 1, 1 >::noneof ( const Expr &  e)
inlinestatic
template<class A , class T , int M, int N>
ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::TMatTransposeFMExprOp ( const A &  a)
inline
template<class A , class T , int M, int N>
value_type ltl::ltl::TMatTransposeFMExprOp< A, T, M, N >::operator() ( const int  i,
const int  j 
) const
inline
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)
inline

Global transpose() matrix.

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)
inline

Global transpose() matrix expression.

template<class A , class B , class T , int M, int N>
ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::TMatVecFVExprOp ( const A &  a,
const B &  b 
)
inline
template<class A , class B , class T , int M, int N>
value_type ltl::ltl::TMatVecFVExprOp< A, B, T, M, N >::operator[] ( const int  i) const
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
template<class A , class B , class T , int N>
static value_type ltl::ltl::tMatVecLoop< A, B, T, N >::eval ( const A &  a,
const B &  b,
const int  i 
)
inlinestatic
template<class A , class B , class T , int N>
static value_type ltl::ltl::tMatVecSplitLoop< A, B, T, N, true >::eval ( const A &  a,
const B &  b,
const int  i 
)
inlinestatic
template<class A , class B , class T , int N>
static value_type ltl::ltl::tMatVecSplitLoop< A, B, T, N, false >::eval ( const A &  a,
const B &  b,
const int  i 
)
inlinestatic
template<class A , class B , class T , int N, int J>
static value_type ltl::ltl::tNMatVecLoop< A, B, T, N, J >::eval ( const A &  a,
const B &  b,
const int  i 
)
inlinestatic
template<class A , class B , class T , int N>
static value_type ltl::ltl::tNMatVecLoop< A, B, T, N, 0 >::eval ( const A &  a,
const B &  b,
const int  i 
)
inlinestatic
template<class A , class B , class T , int N>
ltl::ltl::TMatMatFMExprOp< A, B, T, N >::TMatMatFMExprOp ( const A &  a,
const B &  b 
)
inline
template<class A , class B , class T , int N>
value_type ltl::ltl::TMatMatFMExprOp< A, B, T, N >::operator() ( const int  i,
const int  j 
) const
inline
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 
)
inline
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 
)
inline
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 
)
inline
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 
)
inline
template<class A , class B , class T , int N>
static value_type ltl::ltl::tMatMatLoop< A, B, T, N >::eval ( const A &  a,
const B &  b,
const int  i,
const int  j 
)
inlinestatic
template<class A , class B , class T , int N>
static value_type ltl::ltl::tMatMatSplitLoop< A, B, T, N, true >::eval ( const A &  a,
const B &  b,
const int  i,
const int  j 
)
inlinestatic
template<class A , class B , class T , int N>
static value_type ltl::ltl::tMatMatSplitLoop< A, B, T, N, false >::eval ( const A &  a,
const B &  b,
const int  i,
const int  j 
)
inlinestatic
template<class A , class B , class T , int N, int K>
static value_type ltl::ltl::tNMatMatLoop< A, B, T, N, K >::eval ( const A &  a,
const B &  b,
const int  i,
const int  j 
)
inlinestatic
template<class A , class B , class T , int N>
static value_type ltl::ltl::tNMatMatLoop< A, B, T, N, 1 >::eval ( const A &  a,
const B &  b,
const int  i,
const int  j 
)
inlinestatic
template<class T, int M, int N>
static size_type ltl::ltl::FMatrix< T, M, N >::size ( )
inlinestatic

STL return M*N.

Functions needed for STL container conformance

template<class T, int M, int N>
static bool ltl::ltl::FMatrix< T, M, N >::empty ( )
inlinestatic

STL empty(). Always false.

template<class T, int M, int N>
static size_type ltl::ltl::FMatrix< T, M, N >::max_size ( )
inlinestatic

STL: Maximum capacity. Always ==size()

template<class T, int M, int N>
ltl::ltl::FMatrix< T, M, N >::FMatrix ( )
inline

default constructor

template<class T, int M, int N>
ltl::ltl::FMatrix< T, M, N >::~FMatrix ( )
inline

default destructor

template<class T, int M, int N>
ltl::ltl::FMatrix< T, M, N >::FMatrix ( const FMatrix< T, M, N > &  other)
inline

copy constructor: copy elements of other.

template<class T, int M, int N>
ltl::ltl::FMatrix< T, M, N >::FMatrix ( const T *  t)
inline

copy contents of memory pointed to by t.

template<class T, int M, int N>
ltl::ltl::FMatrix< T, M, N >::FMatrix ( const T  t)
inline

fill with value t.

template<class T , int M, int N>
template<class Expr >
ltl::ltl::FMatrix< T, M, N >::FMatrix ( const FMExprNode< Expr, M, N > &  e)
inline

construct from expression.

template<class T, int M, int N>
ListInitializationSwitch< FMatrix<T,M,N> > ltl::ltl::FMatrix< T, M, N >::operator= ( x)
inline

Initialize with list of values or single value.

Assign values through initialization list. A bit more comlicated since we have to discriminate between A = 3; and A = 1, 2, 3, 4; which is done using ListInitializationSwitch which either calls ListInitializer or FVector::fill().

template<class T, int M, int N>
int ltl::ltl::FMatrix< T, M, N >::length ( ) const
inline

return length of container (M*N).

template<class T, int M, int N>
int ltl::ltl::FMatrix< T, M, N >::nelements ( ) const
inline

return length of container (M*N).

template<class T, int M, int N>
int ltl::ltl::FMatrix< T, M, N >::minIndex ( const int  ) const
inline

return lowest index of dimension dim. Always 1.

template<class T, int M, int N>
int ltl::ltl::FMatrix< T, M, N >::maxIndex ( const int  dim) const
inline

return highest index of dimension dim. Returns M or N.

template<class T, int M, int N>
T ltl::ltl::FMatrix< T, M, N >::operator() ( const int  i,
const int  j 
) const
inline

1-based access to elements.

template<class T, int M, int N>
T& ltl::ltl::FMatrix< T, M, N >::operator() ( const int  i,
const int  j 
)
inline

1-based access to elements.

template<class T, int M, int N>
T ltl::ltl::FMatrix< T, M, N >::operator[] ( const int  i) const
inline

Direct zero-based access to the (linear) block of memory.

template<class T, int M, int N>
T& ltl::ltl::FMatrix< T, M, N >::operator[] ( const int  i)
inline

Direct zero-based access to the (linear) block of memory.

template<class T, int M, int N>
ColumnVector ltl::ltl::FMatrix< T, M, N >::col ( const int  col)
inline

Return an ltl::FVector object REFERENCEING the column vector col.

template<class T, int M, int N>
RowVector ltl::ltl::FMatrix< T, M, N >::row ( const int  row)
inline

Return an ltl::FVector object REFERENCEING the row vector row.

template<class T, int M, int N>
TraceVector ltl::ltl::FMatrix< T, M, N >::traceVector ( )
inline

Return an ltl::FVector object REFERENCEING the trace vector.

template<class T, int M, int N>
T* ltl::ltl::FMatrix< T, M, N >::data ( )
inline

Return a pointer to the data.

template<class T, int M, int N>
const T* ltl::ltl::FMatrix< T, M, N >::data ( ) const
inline

Return a const pointer to the data.

template<class T, int M, int N>
iterator ltl::ltl::FMatrix< T, M, N >::begin ( )
inline

return an iterator pointing to the first element.

template<class T, int M, int N>
const_iterator ltl::ltl::FMatrix< T, M, N >::begin ( ) const
inline

return a const iterator pointing to the first element.

template<class T, int M, int N>
void ltl::ltl::FMatrix< T, M, N >::fill ( const T  x)
inline

fill with value x.

template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator= ( const FMExprNode< Expr, M, N > &  e)
inline

operatorX= for expression rhs.

template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator+= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator-= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator*= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator/= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator%= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator^= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator&= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator|= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator<<= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class Expr >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator>>= ( const FMExprNode< Expr, M, N > &  e)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator= ( const FMatrix< T2, M, N > &  v)
inline

operatorX for FMatrix rhs.

template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator= ( const FMatrix< T, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator+= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator-= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator*= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator/= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator%= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator^= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator&= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator|= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator<<= ( const FMatrix< T2, M, N > &  v)
inline
template<class T , int M, int N>
template<class T2 >
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator>>= ( const FMatrix< T2, M, N > &  v)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator+= ( const T  t)
inline

operatorX= for scalar rhs.

template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator-= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator*= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator/= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator%= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator^= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator&= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator|= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator<<= ( const T  t)
inline
template<class T, int M, int N>
FMatrix< T, M, N > & ltl::ltl::FMatrix< T, M, N >::operator>>= ( const T  t)
inline
template<class T , int M, int N>
void ltl::ltl::FMatrix< T, M, N >::swapRows ( const int  row1,
const int  row2 
)
inline

Swap the values in two row vectors.

template<class T , int M, int N>
void ltl::ltl::FMatrix< T, M, N >::swapCols ( const int  col1,
const int  col2 
)
inline

Swap the values in two column vectors.

template<class X , class Y >
static void ltl::ltl::fm_equ_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_plu_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_min_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_mul_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_div_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_mod_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_xor_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_and_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_bor_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_sle_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class X , class Y >
static void ltl::ltl::fm_sri_assign< X, Y >::eval ( X &  x,
const Y  y 
)
inlinestatic
template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::getPivot ( const FMatrix< T, N, N > &  a,
FVector< int, N > &  ipiv,
tNMatPivot< T > &  p 
)
inlinestaticprotected
template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::swapRows ( FMatrix< T, N, N > &  a,
FVector< T, N > &  b,
tNMatPivot< T > &  p 
)
inlinestaticprotected
template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::divByPiv ( FMatrix< T, N, N > &  a,
const tNMatPivot< T > &  p 
)
inlinestaticprotected
template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::divByPiv ( FMatrix< T, N, N > &  a,
FVector< T, N > &  b,
const tNMatPivot< T > &  p 
)
inlinestaticprotected
template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::elimRow ( FMatrix< T, N, N > &  a,
const tNMatPivot< T > &  p 
)
inlinestaticprotected
template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::elimRow ( FMatrix< T, N, N > &  a,
FVector< T, N > &  b,
const tNMatPivot< T > &  p 
)
inlinestaticprotected
template<class T , int N>
static FMatrix<T, N, N> ltl::ltl::GaussJ< T, N >::invert ( FMatrix< T, N, N >  a)
inlinestatic

invert Matrix, similar to eval() but without solving a linear equation

template<class T , int N>
static FVector<T, N> ltl::ltl::GaussJ< T, N >::solve ( FMatrix< T, N, N >  a,
FVector< T, N >  b 
)
inlinestatic

Return the solution vector x for the equation A x = b

template<class T , int N>
static void ltl::ltl::GaussJ< T, N >::eval ( FMatrix< T, N, N > &  a,
FVector< T, N > &  b 
)
inlinestatic

Solve A x = B by Gauss-Jordan elimination. b is replaced by the solution x, A is replaced by its inverse.

template<class TPAR, class TDAT, int NPAR, int NDIM>
void ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::setData ( const ltl::MArray< TDAT, NDIM > &  indata,
const TDAT  in_nan,
const ltl::MArray< TDAT, NDIM > &  inerror2 
)
inline

Set data, error and NaN value.

template<class TPAR, class TDAT, int NPAR, int NDIM>
void ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::freeData ( )
inline

Free data and error.

template<class TPAR, class TDAT, int NPAR, int NDIM>
static ltl::FVector<TPAR, NPAR> ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::partofit ( const ltl::FVector< TPAR, NPAR > &  parameter)
inlinestatic

Convert external fit parameters to internal representation.

template<class TPAR, class TDAT, int NPAR, int NDIM>
static ltl::FVector<TPAR, NPAR> ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::fittopar ( const ltl::FVector< TPAR, NPAR > &  fitpar,
const typename ltl::FMatrix< TPAR, NPAR, NPAR >::TraceVector &   
)
inlinestatic

Convert internal fit parameters to external representation.

template<class TPAR, class TDAT, int NPAR, int NDIM>
static ltl::FVector<TPAR, NPAR> ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::covtoerr ( const typename ltl::FMatrix< TPAR, NPAR, NPAR >::TraceVector &  trace,
const ltl::FVector< TPAR, NPAR > &   
)
inlinestatic

Calculate external error in parameters from internal covariance matrix.

template<class TPAR, class TDAT, int NPAR, int NDIM>
TPAR ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::marquardtCoefficients ( const ltl::FVector< TPAR, NPAR > &  ,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, NPAR, NPAR > &  a,
ltl::FVector< TPAR, NPAR > &  b 
) const
inline

Calculate actual $\chi^2$ (if better than old one) and Hessematrix.

template<class TPAR, class TDAT, int NPAR, int NDIM>
std::size_t ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::getNdof ( ) const
inline

Return degrees of freedom for fit.

template<class TPAR , class TDAT >
ltl::Gaussian< TPAR, TDAT, 7, 2 >::Gaussian ( )
inline
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 7> ltl::Gaussian< TPAR, TDAT, 7, 2 >::partofit ( const ltl::FVector< TPAR, 7 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 7> ltl::Gaussian< TPAR, TDAT, 7, 2 >::fittopar ( const ltl::FVector< TPAR, 7 > &  fitpar,
const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &   
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 7> ltl::Gaussian< TPAR, TDAT, 7, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &  trace,
const ltl::FVector< TPAR, 7 > &  fitpar 
)
inlinestatic
template<class TPAR , class TDAT >
static void ltl::Gaussian< TPAR, TDAT, 7, 2 >::fill ( const ltl::FVector< TPAR, 7 > &  invalue,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
TPAR ltl::Gaussian< TPAR, TDAT, 7, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 7 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 7, 7 > &  a,
ltl::FVector< TPAR, 7 > &  b 
) const
inline
template<class TPAR , class TDAT >
ltl::Gaussian< TPAR, TDAT, 5, 2 >::Gaussian ( )
inline
template<class TPAR , class TDAT >
void ltl::Gaussian< TPAR, TDAT, 5, 2 >::setData ( const ltl::MArray< TDAT, 2 > &  indata,
const TDAT  in_nan,
const ltl::MArray< TDAT, 2 > &  inerror2 
)
inline
template<class TPAR , class TDAT >
void ltl::Gaussian< TPAR, TDAT, 5, 2 >::freeData ( )
inline
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 5> ltl::Gaussian< TPAR, TDAT, 5, 2 >::partofit ( const ltl::FVector< TPAR, 5 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 5> ltl::Gaussian< TPAR, TDAT, 5, 2 >::fittopar ( const ltl::FVector< TPAR, 5 > &  fitpar,
const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &   
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 5> ltl::Gaussian< TPAR, TDAT, 5, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &  trace,
const ltl::FVector< TPAR, 5 > &  fitpar 
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::MArray<TDAT, 2>& ltl::Gaussian< TPAR, TDAT, 5, 2 >::fill ( const ltl::FVector< TPAR, 5 > &  invalue,
const int  x,
const int  y,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::MArray<TDAT, 2>& ltl::Gaussian< TPAR, TDAT, 5, 2 >::fillExp ( const ltl::FVector< TPAR, 5 > &  invalue,
const int  x,
const int  y,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
TPAR ltl::Gaussian< TPAR, TDAT, 5, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 5 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 5, 5 > &  a,
ltl::FVector< TPAR, 5 > &  b 
) const
inline
template<class TPAR , class TDAT >
ltl::Gaussian< TPAR, TDAT, 3, 2 >::Gaussian ( )
inline
template<class TPAR , class TDAT >
void ltl::Gaussian< TPAR, TDAT, 3, 2 >::setData ( const ltl::MArray< TDAT, 2 > &  indata,
const TDAT  in_nan,
const ltl::MArray< TDAT, 2 > &  inerror2 
)
inline
template<class TPAR , class TDAT >
void ltl::Gaussian< TPAR, TDAT, 3, 2 >::freeData ( )
inline
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 3> ltl::Gaussian< TPAR, TDAT, 3, 2 >::partofit ( const ltl::FVector< TPAR, 3 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 3> ltl::Gaussian< TPAR, TDAT, 3, 2 >::fittopar ( const ltl::FVector< TPAR, 3 > &  fitpar,
const typename ltl::FMatrix< TPAR, 3, 3 >::TraceVector &   
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 3> ltl::Gaussian< TPAR, TDAT, 3, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 3, 3 >::TraceVector &  trace,
const ltl::FVector< TPAR, 3 > &  fitpar 
)
inlinestatic
template<class TPAR , class TDAT >
TPAR ltl::Gaussian< TPAR, TDAT, 3, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 3 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 3, 3 > &  a,
ltl::FVector< TPAR, 3 > &  b 
) const
inline
template<class TPAR , class TDAT >
ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::PolyGaussian ( )
inline
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 7> ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::partofit ( const ltl::FVector< TPAR, 7 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 7> ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::fittopar ( const ltl::FVector< TPAR, 7 > &  fitpar,
const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &  trace 
)
inlinestatic
template<class TPAR , class TDAT >
ltl::FVector<TPAR, 7> ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 7, 7 >::TraceVector &  trace,
const ltl::FVector< TPAR, 7 > &  fitpar 
)
inline
template<class TPAR , class TDAT >
TPAR ltl::PolyGaussian< TPAR, TDAT, 7, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 7 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 7, 7 > &  a,
ltl::FVector< TPAR, 7 > &  b 
) const
inline
template<class TPAR , class TDAT >
ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::PolyGaussian ( )
inline
template<class TPAR , class TDAT >
void ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::setData ( const ltl::MArray< TDAT, 2 > &  indata,
const TDAT  in_nan,
const ltl::MArray< TDAT, 2 > &  inerror2 
)
inline
template<class TPAR , class TDAT >
void ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::freeData ( )
inline
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 5> ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::partofit ( const ltl::FVector< TPAR, 5 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 5> ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::fittopar ( const ltl::FVector< TPAR, 5 > &  fitpar,
const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &  trace 
)
inlinestatic
template<class TPAR , class TDAT >
ltl::FVector<TPAR, 5> ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 5, 5 >::TraceVector &  trace,
const ltl::FVector< TPAR, 5 > &  fitpar 
)
inline
template<class TPAR , class TDAT >
static ltl::MArray<TDAT, 2>& ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::fill ( const ltl::FVector< TPAR, 5 > &  invalue,
const int  x,
const int  y,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::MArray<TDAT, 2>& ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::fillExp ( const ltl::FVector< TPAR, 5 > &  invalue,
const int  x,
const int  y,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
TPAR ltl::PolyGaussian< TPAR, TDAT, 5, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 5 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 5, 5 > &  a,
ltl::FVector< TPAR, 5 > &  b 
) const
inline
template<class TPAR , class TDAT >
ltl::Moffat< TPAR, TDAT, 10, 2 >::Moffat ( )
inline
template<class TPAR , class TDAT >
static void ltl::Moffat< TPAR, TDAT, 10, 2 >::fill ( const ltl::FVector< TPAR, 10 > &  invalue,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
TPAR ltl::Moffat< TPAR, TDAT, 10, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 10 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 10, 10 > &  a,
ltl::FVector< TPAR, 10 > &  b 
) const
inline
template<class TPAR , class TDAT >
ltl::Moffat< TPAR, TDAT, 8, 2 >::Moffat ( )
inline
template<class TPAR , class TDAT >
static void ltl::Moffat< TPAR, TDAT, 8, 2 >::fill ( const ltl::FVector< TPAR, 8 > &  invalue,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
TPAR ltl::Moffat< TPAR, TDAT, 8, 2 >::marquardtCoefficients ( const ltl::FVector< TPAR, 8 > &  parameter,
const TPAR  chisquare_limit,
ltl::FMatrix< TPAR, 8, 8 > &  a,
ltl::FVector< TPAR, 8 > &  b 
) const
inline
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 10> ltl::DegMoffat< TPAR, TDAT, 10, 2 >::partofit ( const ltl::FVector< TPAR, 10 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 10> ltl::DegMoffat< TPAR, TDAT, 10, 2 >::fittopar ( const ltl::FVector< TPAR, 10 > &  fitpar,
const typename ltl::FMatrix< TPAR, 10, 10 >::TraceVector &   
)
inlinestatic
template<class TPAR , class TDAT >
ltl::FVector<TPAR, 10> ltl::DegMoffat< TPAR, TDAT, 10, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 10, 10 >::TraceVector &  trace,
const ltl::FVector< TPAR, 10 > &   
)
inline
template<class TPAR , class TDAT >
static void ltl::DegMoffat< TPAR, TDAT, 8, 2 >::fill ( const ltl::FVector< TPAR, 8 > &  invalue,
ltl::MArray< TDAT, 2 > &  a 
)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 8> ltl::DegMoffat< TPAR, TDAT, 8, 2 >::partofit ( const ltl::FVector< TPAR, 8 > &  parameter)
inlinestatic
template<class TPAR , class TDAT >
static ltl::FVector<TPAR, 8> ltl::DegMoffat< TPAR, TDAT, 8, 2 >::fittopar ( const ltl::FVector< TPAR, 8 > &  fitpar,
const typename ltl::FMatrix< TPAR, 8, 8 >::TraceVector &   
)
inlinestatic
template<class TPAR , class TDAT >
ltl::FVector<TPAR, 8> ltl::DegMoffat< TPAR, TDAT, 8, 2 >::covtoerr ( const typename ltl::FMatrix< TPAR, 8, 8 >::TraceVector &  trace,
const ltl::FVector< TPAR, 8 > &   
)
inline
template<class TFUNC , class TPAR , class TDAT , int NPAR, int NDIM>
ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::Marquardt ( const std::size_t  initer,
const TPAR  ainstart,
const TPAR  ainstep,
const TPAR  ainmin,
const TPAR  ainmax,
const FVector< bool, NPAR >  ignin = false 
)
inline

Construct class with fit constraints.

template<class TFUNC , class TPAR , class TDAT , int NPAR, int NDIM>
void ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::eval ( const MArray< TDAT, NDIM > &  data,
const TDAT  nan,
const MArray< TDAT, NDIM > &  error2,
const FVector< TPAR, NPAR > &  inpar 
)
inline

Fit to data and $error^2$ ignoring nan, start with inpar.

template<class TFUNC , class TPAR , class TDAT , int NPAR, int NDIM>
FVector<TPAR, NPAR> ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getResult ( )
inline

Return result vector.

template<class TFUNC , class TPAR , class TDAT , int NPAR, int NDIM>
TPAR ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getChiSquare ( ) const
inline

Return final $\chi^2$.

template<class TFUNC , class TPAR , class TDAT , int NPAR, int NDIM>
std::size_t ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getNIteration ( ) const
inline

Return No needed iterations.

template<class TFUNC , class TPAR , class TDAT , int NPAR, int NDIM>
FVector<TPAR, NPAR> ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getVariance ( )
inline

Return $error^2$ in fit parameters.

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator+= ( const MArray< T2, N > &  a)
inline

operator+=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator+= ( const ExprNode< Expr, N > &  e)
inline

operator+=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator+= ( const T  a)
inline

operator+=

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator-= ( const MArray< T2, N > &  a)
inline

operator-=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator-= ( const ExprNode< Expr, N > &  e)
inline

operator-=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator-= ( const T  a)
inline

operator-=

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator*= ( const MArray< T2, N > &  a)
inline

operator*=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator*= ( const ExprNode< Expr, N > &  e)
inline

operator*=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator*= ( const T  a)
inline

operator*=

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator/= ( const MArray< T2, N > &  a)
inline

operator/=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator/= ( const ExprNode< Expr, N > &  e)
inline

operator/=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator/= ( const T  a)
inline

operator/=

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator|= ( const MArray< T2, N > &  a)
inline

operator|=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator|= ( const ExprNode< Expr, N > &  e)
inline

operator|=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator|= ( const T  a)
inline

operator|=

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator&= ( const MArray< T2, N > &  a)
inline

operator&=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator&= ( const ExprNode< Expr, N > &  e)
inline

operator&=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator&= ( const T  a)
inline

operator&=

template<typename T , int N>
template<typename T2 >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator^= ( const MArray< T2, N > &  a)
inline

operator^=

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator^= ( const ExprNode< Expr, N > &  e)
inline

operator^=

template<typename T, int N>
MArray< T, N > & ltl::ltl::MArray< T, N >::operator^= ( const T  a)
inline

operator^=

template<typename T, int N>
ltl::ltl::MArray< T, N >::MArray ( T *  data,
const int dims 
)

Construct from allocated memory. Note that this memory will be freed when the MArray is destructed.

template<typename T, int N>
ltl::ltl::MArray< T, N >::MArray ( const std::string  filename,
const int dims 
)

Construct from map file.

template<typename T, int N>
template<typename Expr>
ltl::ltl::MArray< T, N >::MArray ( const ExprNode< Expr, N > &  e,
const bool  map = false,
const char *  filename = NULL 
)

Construct from an array-valued expression.

The new array is allocated with the shape of the expression and its elements are filled with the evaluated expression. If you have map == true and give a filename the memory map will be saved.

template<typename T, int N>
ltl::ltl::MArray< T, N >::MArray ( const Shape< N > *  s,
const bool  map = false,
const char *  filename = NULL 
)

Construct from shape.

Useful to construct an array having the same geometry as another array. If you have map == true and give a filename the memory map will be saved.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::makeReference ( const MArray< T, N > &  other)

Make this being a referece to other's data.

template<typename T, int N>
template<int N2>
void ltl::ltl::MArray< T, N >::makeReferenceWithDims ( const MArray< T, N2 > &  other,
const int dims 
)

Make a reference as a different-dimensional view of another MArray's data.

The new array is referencing the other's data but takes it to have rank N instead of N2 and dimensions dims[0] ... dims[N-1]. Use with care. Memory must be contiguous.

template<typename T , int N>
void ltl::ltl::MArray< T, N >::realloc ( const Shape< N > &  s,
const bool  map = false,
const char *  filename = NULL 
)

Reallocate memory. Data are abolished.

If you have map == true and give a filename the new memory map will be saved.

template<typename T , int N>
template<typename Expr >
MArray< T, N > & ltl::ltl::MArray< T, N >::operator= ( const ExprNode< Expr, N > &  e)
inline

Assignment of an expression to a MArray.

The MArray and the expression have to have conformable shapes, no automatic resize takes place. Use realloc() instead! If the lhs ltl::MArray is empty(), i.e. no memory has been allocated then memory conforming to the expression's shape will be allocated.

template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1,
const int  b2 
)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1,
const int  b2,
const int  b3 
)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1,
const int  b2,
const int  b3,
const int  b4 
)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1,
const int  b2,
const int  b3,
const int  b4,
const int  b5 
)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1,
const int  b2,
const int  b3,
const int  b4,
const int  b5,
const int  b6 
)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setBase ( const int  b1,
const int  b2,
const int  b3,
const int  b4,
const int  b5,
const int  b6,
const int  b7 
)
template<typename T , int N>
void ltl::ltl::MArray< T, N >::reverseSelf ( const int  dim = 1)

Reverse this MArray.

Reverse dimension dim, keep index range unchanged, such that the following holds: A'( I ) = A( last-I+1 ). Note that the base is unchanged, so that if A(3) refered to the first element, now A'(3) holds the value of the former last element. Equation for offset:
data_ + last_ * stride_ = data_ + offset + base * stride * (-1)

template<typename T , int N>
MArray< T, N > ltl::ltl::MArray< T, N >::reverse ( const int  dim = 1) const

Return reversed MArray.

template<typename T , int N>
void ltl::ltl::MArray< T, N >::transposeSelf ( const int  dim1 = 1,
const int  dim2 = 2 
)

Transpose this MArray.

template<typename T , int N>
MArray< T, N > ltl::ltl::MArray< T, N >::transpose ( const int  dim1 = 1,
const int  dim2 = 2 
) const

Return transposed MArray.

template<typename T , int N>
void ltl::ltl::MArray< T, N >::describeSelf ( ) const

Debug output. Print geometry information.

template<typename T , int N>
template<typename T2 >
void ltl::ltl::MArray< T, N >::copy ( const MArray< T2, N > &  other)
inlineprotected

Copy from other.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::fill ( const T  t)
inlineprotected

Fill with t.

template<typename T , int N>
void ltl::ltl::MArray< T, N >::setupMemory ( const bool  map = false,
const char *  filename = NULL 
)
protected
template<typename T , int N>
void ltl::ltl::MArray< T, N >::setupShape ( const int dims)
protected
template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1 
)
protected

Constructs a pure subarray of other, i.e. rank is preserved.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1,
const Range r2 
)
protected

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1,
const Range r2,
const Range r3 
)
protected

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1,
const Range r2,
const Range r3,
const Range r4 
)
protected

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1,
const Range r2,
const Range r3,
const Range r4,
const Range r5 
)
protected

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1,
const Range r2,
const Range r3,
const Range r4,
const Range r5,
const Range r6 
)
protected

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T, int N>
void ltl::ltl::MArray< T, N >::subarray ( const MArray< T, N > &  other,
const Range r1,
const Range r2,
const Range r3,
const Range r4,
const Range r5,
const Range r6,
const Range r7 
)
protected

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T , int N>
void ltl::ltl::MArray< T, N >::setrange ( const int  dim,
const Range r 
)
protected

'Cut out' the ltl::Range r in dimension dim, used for rank-preserving subarrays. Range is reset to base of 1, such that if you have Range(3,10) and you cut out Range(5,8) you get a dimension having Range(1:3).

Equation for offset:
data_ + f*stride_(dim) = data_ + offset + 1*stride_(dim)*s

template<typename T, int N>
template<int N2, typename R1 , typename R2 , typename R3 , typename R4 , typename R5 , typename R6 , typename R7 >
void ltl::ltl::MArray< T, N >::slicearray ( const MArray< T, N2 > &  other,
R1  r1,
R2  r2,
R3  r3,
R4  r4,
R5  r5,
R6  r6,
R7  r7 
)
protected

Weird version of slicearray dealing with the case that some dimensions are slices, i.e. we have a mixture of Range and int arguments. There are two versions of slice() below being called for each dimension: one version has a Range argument, the other an int argument.

template<typename T, int N>
template<int N2>
void ltl::ltl::MArray< T, N >::slice ( int setRank,
Range  r,
const MArray< T, N2 > &  other,
int  sourceRank 
)
protected

ltl::Range version of slice(): Essentially a subarray in this dimension.

template<typename T, int N>
template<int N2>
void ltl::ltl::MArray< T, N >::slice ( int setRank,
int  r,
const MArray< T, N2 > &  other,
int  sourceRank 
)
inlineprotected

int version of slice(): slice in this dimension, rank is reduced by one.

template<class T , int M, int N>
std::ostream & operator<< ( std::ostream &  os,
const FMatrix< T, M, N > &  A 
)
related

Write ltl::FVector to ascii stream. Compatible with opertor>>.

template<class T , int M, int N>
std::istream & operator>> ( std::istream &  is,
FMatrix< T, M, N > &  A 
)
related

Read ltl::FMatrix from ascii stream. Compatible with operator<<.

Variable Documentation

template<class T , int M, int N>
T* ltl::ltl::FMIterConst< T, M, N >::__data_
protected
template<class T , int M, int N>
T* ltl::ltl::FMIter< T, M, N >::__data_
protected
template<class T, int M, int N>
T ltl::ltl::FMatrix< T, M, N >::__data_[M *N]
protected

Storage for the matrix elements.

template<class TPAR, class TDAT, int NPAR, int NDIM>
ltl::MArray<TDAT, NDIM> ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::data_
protected
template<class TPAR, class TDAT, int NPAR, int NDIM>
TDAT ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::nan_data_
protected
template<class TPAR, class TDAT, int NPAR, int NDIM>
ltl::MArray<TDAT, NDIM> ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::error2_
protected
template<class TPAR, class TDAT, int NPAR, int NDIM>
int ltl::MRQFunction< TPAR, TDAT, NPAR, NDIM >::ndof_
protected

Friends

template<class T, int M, int N>
friend class FMIter< T, M, N >
friend
template<class T, int M, int N>
friend class FMIterConst< T, M, N >
friend
template<class T, int M, int N>
friend class ListInitializationSwitch< FMatrix< T, M, N > >
friend