SmallMatrixMixed.h File Reference

This file defines global functions and class members which use a mix of Vec, Row, and Mat types and hence need to wait until everything is defined. More...

Go to the source code of this file.

Namespaces

namespace  SimTK
 

This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols.


Functions

template<int M, class E1 , int S1, class E2 , int S2>
CNT< typename CNT< E1 >::THerm >
::template Result< E2 >::Mul 
dot (const Vec< M, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<class E1 , int S1, class E2 , int S2>
CNT< typename CNT< E1 >::THerm >
::template Result< E2 >::Mul 
dot (const Vec< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
operator* (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
operator* (const Row< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
dot (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v)
template<int M, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
dot (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
dot (const Row< N, E1, S1 > &r, const Row< N, E2, S2 > &s)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >
::template Result< typename
CNT< E2 >::THerm >::Mul > 
outer (const Vec< M, E1, S1 > &v, const Vec< M, E2, S2 > &w)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template
Result< Row< M, E2, S2 >
>::Mul 
operator* (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >
::template Result< E2 >::Mul > 
outer (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >
::template Result< E2 >::Mul > 
outer (const Row< M, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >
::template Result< E2 >::Mul > 
outer (const Row< M, E1, S1 > &r, const Row< M, E2, S2 > &s)
template<int M, int N, class ME , int CS, int RS, class E , int S>
Mat< M, N, ME, CS, RS >
::template Result< Vec< N, E,
S > >::Mul 
operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< N, E, S > &v)
template<int M, class E , int S, int N, class ME , int CS, int RS>
Row< M, E, S >::template
Result< Mat< M, N, ME, CS, RS >
>::Mul 
operator* (const Row< M, E, S > &r, const Mat< M, N, ME, CS, RS > &m)
template<int N, class ME , int RS, class E , int S>
SymMat< N, ME, RS >::template
Result< Vec< N, E, S > >::Mul 
operator* (const SymMat< N, ME, RS > &m, const Vec< N, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 1, ME, RS >::template
Result< Vec< 1, E, S > >::Mul 
operator* (const SymMat< 1, ME, RS > &m, const Vec< 1, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 2, ME, RS >::template
Result< Vec< 2, E, S > >::Mul 
operator* (const SymMat< 2, ME, RS > &m, const Vec< 2, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 3, ME, RS >::template
Result< Vec< 3, E, S > >::Mul 
operator* (const SymMat< 3, ME, RS > &m, const Vec< 3, E, S > &v)
template<int M, class E , int S, class ME , int RS>
Row< M, E, S >::template
Result< SymMat< M, ME, RS >
>::Mul 
operator* (const Row< M, E, S > &r, const SymMat< M, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 1, E, S >::template
Result< SymMat< 1, ME, RS >
>::Mul 
operator* (const Row< 1, E, S > &r, const SymMat< 1, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 2, E, S >::template
Result< SymMat< 2, ME, RS >
>::Mul 
operator* (const Row< 2, E, S > &r, const SymMat< 2, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 3, E, S >::template
Result< SymMat< 3, ME, RS >
>::Mul 
operator* (const Row< 3, E, S > &r, const SymMat< 3, ME, RS > &m)
template<int M, class E1 , int S1, int N, class E2 , int S2>
Vec< M, E1, S1 >::template
Result< Row< N, E2, S2 >
>::MulNon 
operator* (const Vec< M, E1, S1 > &v, const Row< N, E2, S2 > &r)
template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2>
Vec< M, E1, S1 >::template
Result< Mat< MM, NN, E2, CS2,
RS2 > >::MulNon 
operator* (const Vec< M, E1, S1 > &v, const Mat< MM, NN, E2, CS2, RS2 > &m)
template<int M, class E1 , int S1, int MM, class E2 , int RS2>
Vec< M, E1, S1 >::template
Result< SymMat< MM, E2, RS2 >
>::MulNon 
operator* (const Vec< M, E1, S1 > &v, const SymMat< MM, E2, RS2 > &m)
template<int M, class E1 , int S1, int MM, class E2 , int S2>
Vec< M, E1, S1 >::template
Result< Vec< MM, E2, S2 >
>::MulNon 
operator* (const Vec< M, E1, S1 > &v1, const Vec< MM, E2, S2 > &v2)
template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS>
Row< M, E, S >::template
Result< Mat< MM, NN, ME, CS,
RS > >::MulNon 
operator* (const Row< M, E, S > &r, const Mat< MM, NN, ME, CS, RS > &m)
template<int N, class E1 , int S1, int M, class E2 , int S2>
Row< N, E1, S1 >::template
Result< Vec< M, E2, S2 >
>::MulNon 
operator* (const Row< N, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<int N1, class E1 , int S1, int N2, class E2 , int S2>
Row< N1, E1, S1 >::template
Result< Row< N2, E2, S2 >
>::MulNon 
operator* (const Row< N1, E1, S1 > &r1, const Row< N2, E2, S2 > &r2)
template<int M, int N, class ME , int CS, int RS, int MM, class E , int S>
Mat< M, N, ME, CS, RS >
::template Result< Vec< MM, E,
S > >::MulNon 
operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< MM, E, S > &v)
template<int M, int N, class ME , int CS, int RS, int NN, class E , int S>
Mat< M, N, ME, CS, RS >
::template Result< Row< NN, E,
S > >::MulNon 
operator* (const Mat< M, N, ME, CS, RS > &m, const Row< NN, E, S > &r)
template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S>
Mat< M, N, ME, CS, RS >
::template Result< SymMat< Dim,
E, S > >::MulNon 
operator* (const Mat< M, N, ME, CS, RS > &m, const SymMat< Dim, E, S > &sy)
template<class E1 , int S1, class E2 , int S2>
Vec< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
cross (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Vec< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
operator% (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
cross (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
operator% (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
cross (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
operator% (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
cross (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > 
operator% (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > 
cross (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > 
operator% (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > 
cross (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > 
operator% (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m)
template<int M, class EM , int CS, int RS, class EV , int S>
Mat< M, 3, typename CNT< EM >
::template Result< EV >::Mul > 
cross (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v)
template<int M, class EM , int CS, int RS, class EV , int S>
Mat< M, 3, typename CNT< EM >
::template Result< EV >::Mul > 
operator% (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v)
template<int M, class EM , int CS, int RS, class ER , int S>
Mat< M, 3, typename CNT< EM >
::template Result< ER >::Mul > 
cross (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r)
template<int M, class EM , int CS, int RS, class ER , int S>
Mat< M, 3, typename CNT< EM >
::template Result< ER >::Mul > 
operator% (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
cross (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
operator% (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
cross (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
operator% (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
cross (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
operator% (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
cross (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >
::Mul 
operator% (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E , int S>
Mat< 3, 3, E > crossMat (const Vec< 3, E, S > &v)
 Calculate matrix M(v) such that M(v)*w = v % w.
template<class E , int S>
Mat< 3, 3, E > crossMat (const Vec< 3, negator< E >, S > &v)
 Specialize crossMat() for negated scalar types.
template<class E , int S>
Mat< 3, 3, E > crossMat (const Row< 3, E, S > &r)
 Form cross product matrix from a Row vector; 3 flops.
template<class E , int S>
Mat< 3, 3, E > crossMat (const Row< 3, negator< E >, S > &r)
 Form cross product matrix from a Row vector whose elements are negated scalars; 3 flops.
template<class E , int S>
Row< 2, E > crossMat (const Vec< 2, E, S > &v)
 Calculate 2D cross product matrix M(v) such that M(v)*w = v0*w1-v1*w0 = v % w (a scalar).
template<class E , int S>
Row< 2, E > crossMat (const Vec< 2, negator< E >, S > &v)
 Specialize 2D cross product matrix for negated scalar types; 1 flop.
template<class E , int S>
Row< 2, E > crossMat (const Row< 2, E, S > &r)
 Form 2D cross product matrix from a Row<2>; 1 flop.
template<class E , int S>
Row< 2, E > crossMat (const Row< 2, negator< E >, S > &r)
 Form 2D cross product matrix from a Row<2> with negated scalar elements; 1 flop.
template<class E , int S>
SymMat< 3, E > crossMatSq (const Vec< 3, E, S > &v)
 Calculate matrix S(v) such that S(v)*w = -v % (v % w) = (vw)v.
template<class E , int S>
SymMat< 3, E > crossMatSq (const Vec< 3, negator< E >, S > &v)
template<class E , int S>
SymMat< 3, E > crossMatSq (const Row< 3, E, S > &r)
template<class E , int S>
SymMat< 3, E > crossMatSq (const Row< 3, negator< E >, S > &r)
template<class E , int CS, int RS>
const E & det (const Mat< 1, 1, E, CS, RS > &m)
 Special case 1x1 determinant. No computation.
template<class E , int CS, int RS>
det (const Mat< 2, 2, E, CS, RS > &m)
 Special case 2x2 determinant. 3 flops.
template<class E , int CS, int RS>
det (const Mat< 3, 3, E, CS, RS > &m)
 Special case 3x3 determinant. 14 flops.
template<int M, class E , int CS, int RS>
det (const Mat< M, M, E, CS, RS > &m)
 Calculate the determinant of a square matrix larger than 3x3 by recursive template expansion.
template<class E , int CS, int RS>
Mat< 1, 1, E, CS, RS >::TInvert lapackInverse (const Mat< 1, 1, E, CS, RS > &m)
 Specialized 1x1 lapackInverse(): costs one divide.
template<int M, class E , int CS, int RS>
Mat< M, M, E, CS, RS >::TInvert lapackInverse (const Mat< M, M, E, CS, RS > &m)
 General inverse of small, fixed-size, square (mXm), non-singular matrix with scalar elements: use Lapack's LU routine with pivoting.
template<class E , int CS, int RS>
Mat< 1, 1, E, CS, RS >::TInvert inverse (const Mat< 1, 1, E, CS, RS > &m)
 Specialized 1x1 inverse: costs one divide.
template<class E , int CS, int RS>
Mat< 2, 2, E, CS, RS >::TInvert inverse (const Mat< 2, 2, E, CS, RS > &m)
 Specialized 2x2 inverse: costs one divide plus 9 flops.
template<class E , int CS, int RS>
Mat< 3, 3, E, CS, RS >::TInvert inverse (const Mat< 3, 3, E, CS, RS > &m)
 Specialized 3x3 inverse: costs one divide plus 45 flops (for real-valued matrices).
template<int M, class E , int CS, int RS>
Mat< M, M, E, CS, RS >::TInvert inverse (const Mat< M, M, E, CS, RS > &m)
 For any matrix larger than 3x3, we just punt to the Lapack implementation.

Detailed Description

This file defines global functions and class members which use a mix of Vec, Row, and Mat types and hence need to wait until everything is defined.

Some of them may depend on Lapack also.


Generated by  doxygen 1.6.2