|
| 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< A, M, N >::FMExprNode (const A &a) |
|
value_type | ltl::ltl::FMExprNode< A, M, N >::operator() (const int i, const int j) const |
|
value_type | ltl::ltl::FMExprNode< A, 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_j0< T >, M, N >, M, N > | ltl::ltl::j0 (const FMatrix< T, M, N > &a) |
|
template<class A , int M, int N> |
FMExprNode< FMExprUnopNode< FMExprNode< A, M, N >, __ltl_j0< typename A::value_type >, M, N >, M, N > | ltl::ltl::j0 (const FMExprNode< A, M, N > &a) |
|
template<class T , int M, int N> |
FMExprNode< FMExprUnopNode< typename FMatrix< T, M, N >::const_iterator, __ltl_j1< T >, M, N >, M, N > | ltl::ltl::j1 (const FMatrix< T, M, N > &a) |
|
template<class A , int M, int N> |
FMExprNode< FMExprUnopNode< FMExprNode< A, M, N >, __ltl_j1< typename A::value_type >, M, N >, M, N > | ltl::ltl::j1 (const FMExprNode< A, M, N > &a) |
|
template<class T , int M, int N> |
FMExprNode< FMExprUnopNode< typename FMatrix< T, M, N >::const_iterator, __ltl_y0< T >, M, N >, M, N > | ltl::ltl::y0 (const FMatrix< T, M, N > &a) |
|
template<class A , int M, int N> |
FMExprNode< FMExprUnopNode< FMExprNode< A, M, N >, __ltl_y0< typename A::value_type >, M, N >, M, N > | ltl::ltl::y0 (const FMExprNode< A, M, N > &a) |
|
template<class T , int M, int N> |
FMExprNode< FMExprUnopNode< typename FMatrix< T, M, N >::const_iterator, __ltl_y1< T >, M, N >, M, N > | ltl::ltl::y1 (const FMatrix< T, M, N > &a) |
|
template<class A , int M, int N> |
FMExprNode< FMExprUnopNode< FMExprNode< A, M, N >, __ltl_y1< typename A::value_type >, M, N >, M, N > | ltl::ltl::y1 (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 (if better than old one) and Hessematrix. More...
|
|
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 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 ignoring nan, start with inpar. More...
|
|
FVector< TPAR, NPAR > | ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getResult () |
| Return result vector. More...
|
|
TPAR | ltl::Marquardt< TFUNC, TPAR, TDAT, NPAR, NDIM >::getChiSquare () const |
| Return final . More...
|
|
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 in fit parameters. More...
|
|
template<typename Expr > |
| ltl::ltl::MArray< T, N >::MArray (const ExprNode< Expr, N > &e, const bool map=false, const char *filename=NULL) |
| Construct from an array-valued expression. More...
|
|
| ltl::ltl::MArray< T, N >::MArray (const Shape< N > *s, const bool map=false, const char *filename=NULL) |
| Construct from shape. More...
|
|
void | ltl::ltl::MArray< T, N >::makeReference (const MArray< T, N > &other) |
| Make this being a referece to other's data. More...
|
|
template<int N2> |
void | ltl::ltl::MArray< T, N >::makeReferenceWithDims (const MArray< T, N2 > &other, const int *dims) |
| Make a reference as a different-dimensional view of another MArray's data. More...
|
|
void | ltl::ltl::MArray< T, N >::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, N >::operator= (const ExprNode< Expr, N > &e) |
| Assignment of an expression to a MArray . More...
|
|
void | ltl::ltl::MArray< T, N >::describeSelf () const |
| Debug output. Print geometry information. More...
|
|
template<typename T2 > |
void | ltl::ltl::MArray< T, N >::copy (const MArray< T2, N > &other) |
| Copy from other. More...
|
|
void | ltl::ltl::MArray< T, N >::fill (const T t) |
| Fill with t. More...
|
|
void | ltl::ltl::MArray< T, N >::setupMemory (const bool map=false, const char *filename=NULL) |
|
void | ltl::ltl::MArray< T, N >::setupShape (const int *dims) |
|
void | ltl::ltl::MArray< T, N >::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, N >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2) |
|
void | ltl::ltl::MArray< T, N >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3) |
|
void | ltl::ltl::MArray< T, N >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4) |
|
void | ltl::ltl::MArray< T, N >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4, const Range &r5) |
|
void | ltl::ltl::MArray< T, N >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4, const Range &r5, const Range &r6) |
|
void | ltl::ltl::MArray< T, N >::subarray (const MArray< T, N > &other, const Range &r1, const Range &r2, const Range &r3, const Range &r4, const Range &r5, const Range &r6, const Range &r7) |
|
void | ltl::ltl::MArray< T, N >::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, N >::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, N >::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, N >::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> |
ostream & | operator<< (ostream &os, const FMatrix< T, M, N > &A) |
|
template<class T , int M, int N> |
istream & | operator>> (istream &is, FMatrix< T, M, N > &A) |
|