LTL
2.0.x
|
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) |
Functions | |
ltl::ltl::FMIterConst< T, M, N >::FMIterConst (const FMatrix< T, M, N > &m) | |
T | ltl::ltl::FMIterConst< T, M, N >::operator[] (const int i) const |
T | 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) | |
T | ltl::ltl::FMIter< T, M, N >::operator[] (const int i) const |
T & | ltl::ltl::FMIter< T, M, N >::operator[] (const int i) |
T | 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 > ¶meter) |
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 ![]() | |
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 > ¶meter) |
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 > ¶meter, 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 > ¶meter) |
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 > ¶meter, 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 > ¶meter) |
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 > ¶meter, 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 > ¶meter) |
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 > ¶meter, 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 > ¶meter) |
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 > ¶meter, 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 > ¶meter, 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 > ¶meter, 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 > ¶meter) |
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 > ¶meter) |
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 ![]() | |
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 ![]() | |
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 ![]() | |
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_ |
T | 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_ |
Construct from preexisting data. | |
The array | |
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: | |
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... | |
T | 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... | |
T | 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) |
#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 | |||
) |
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 T ltl::ltl::FMatrix< T, M, N >::value_type |
STL-compatible type definitions.
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 |
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 |
anonymous enum |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inline |
Global transpose() matrix.
|
inline |
Global transpose() matrix expression.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
STL return M*N
.
Functions needed for STL container conformance
|
inlinestatic |
STL empty()
. Always false.
|
inlinestatic |
STL: Maximum capacity. Always ==size()
|
inline |
default constructor
|
inline |
default destructor
|
inline |
copy constructor: copy elements of other
.
|
inline |
copy contents of memory pointed to by t
.
|
inline |
fill with value t
.
|
inline |
construct from expression.
|
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()
.
|
inline |
return length of container (M*N).
|
inline |
return length of container (M*N).
|
inline |
return lowest index of dimension dim
. Always 1.
|
inline |
return highest index of dimension dim
. Returns M or N.
|
inline |
1-based access to elements.
|
inline |
1-based access to elements.
|
inline |
Direct zero-based access to the (linear) block of memory.
|
inline |
Direct zero-based access to the (linear) block of memory.
|
inline |
Return an ltl::FVector object REFERENCEING the column vector col
.
|
inline |
Return an ltl::FVector object REFERENCEING the row vector row
.
|
inline |
Return an ltl::FVector object REFERENCEING the trace vector.
|
inline |
Return a pointer to the data.
|
inline |
Return a const pointer to the data.
|
inline |
return an iterator pointing to the first element.
|
inline |
return a const iterator pointing to the first element.
|
inline |
fill with value x
.
|
inline |
operatorX=
for expression rhs.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
operatorX for FMatrix
rhs.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
operatorX= for scalar rhs.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
Swap the values in two row vectors.
|
inline |
Swap the values in two column vectors.
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestaticprotected |
|
inlinestaticprotected |
|
inlinestaticprotected |
|
inlinestaticprotected |
|
inlinestaticprotected |
|
inlinestaticprotected |
|
inlinestatic |
invert Matrix, similar to eval() but without solving a linear equation
|
inlinestatic |
Return the solution vector x
for the equation A x = b
|
inlinestatic |
Solve A x = B
by Gauss-Jordan elimination. b is replaced by the solution x, A is replaced by its inverse.
|
inline |
Set data, error and NaN value.
|
inline |
Free data and error.
|
inlinestatic |
Convert external fit parameters to internal representation.
|
inlinestatic |
Convert internal fit parameters to external representation.
|
inlinestatic |
Calculate external error in parameters from internal covariance matrix.
|
inline |
Calculate actual (if better than old one) and Hessematrix.
|
inline |
Return degrees of freedom for fit.
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
|
inlinestatic |
|
inline |
|
inline |
|
inlinestatic |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
|
inline |
Construct class with fit constraints.
|
inline |
Fit to data and ignoring nan, start with inpar.
|
inline |
Return result vector.
|
inline |
Return final .
|
inline |
Return No needed iterations.
|
inline |
Return in fit parameters.
|
inline |
operator+=
|
inline |
operator+=
|
inline |
operator+=
|
inline |
operator-=
|
inline |
operator-=
|
inline |
operator-=
|
inline |
operator*=
|
inline |
operator*=
|
inline |
operator*=
|
inline |
operator/=
|
inline |
operator/=
|
inline |
operator/=
|
inline |
operator|=
|
inline |
operator|=
|
inline |
operator|=
|
inline |
operator&=
|
inline |
operator&=
|
inline |
operator&=
|
inline |
operator^=
|
inline |
operator^=
|
inline |
operator^=
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.
ltl::ltl::MArray< T, N >::MArray | ( | const std::string | filename, |
const int * | dims | ||
) |
Construct from map file.
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.
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.
void ltl::ltl::MArray< T, N >::makeReference | ( | const MArray< T, N > & | other | ) |
Make this being a referece to other's data.
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.
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.
|
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.
void ltl::ltl::MArray< T, N >::setBase | ( | const int | b1 | ) |
void ltl::ltl::MArray< T, N >::setBase | ( | const int | b1, |
const int | b2 | ||
) |
void ltl::ltl::MArray< T, N >::setBase | ( | const int | b1, |
const int | b2, | ||
const int | b3 | ||
) |
void ltl::ltl::MArray< T, N >::setBase | ( | const int | b1, |
const int | b2, | ||
const int | b3, | ||
const int | b4 | ||
) |
void ltl::ltl::MArray< T, N >::setBase | ( | const int | b1, |
const int | b2, | ||
const int | b3, | ||
const int | b4, | ||
const int | b5 | ||
) |
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 | ||
) |
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 | ||
) |
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)
MArray< T, N > ltl::ltl::MArray< T, N >::reverse | ( | const int | dim = 1 | ) | const |
Return reversed MArray.
void ltl::ltl::MArray< T, N >::transposeSelf | ( | const int | dim1 = 1 , |
const int | dim2 = 2 |
||
) |
Transpose this MArray.
MArray< T, N > ltl::ltl::MArray< T, N >::transpose | ( | const int | dim1 = 1 , |
const int | dim2 = 2 |
||
) | const |
Return transposed MArray.
void ltl::ltl::MArray< T, N >::describeSelf | ( | ) | const |
Debug output. Print geometry information.
|
inlineprotected |
Copy from other.
|
inlineprotected |
Fill with t.
|
protected |
|
protected |
|
protected |
Constructs a pure subarray of other, i.e. rank is preserved.
|
protected |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
protected |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
protected |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
protected |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
protected |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
protected |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
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
|
protected |
|
protected |
ltl::Range version of slice(): Essentially a subarray in this dimension.
|
inlineprotected |
int
version of slice(): slice in this dimension, rank is reduced by one.
|
related |
Write ltl::FVector to ascii stream. Compatible with opertor>>
.
|
related |
Read ltl::FMatrix from ascii stream. Compatible with operator<<
.
|
protected |
|
protected |
|
protected |
Storage for the matrix elements.
|
protected |
|
protected |
|
protected |
|
protected |
|
friend |
|
friend |
|
friend |