Simbody  3.5
SymMat.h File Reference

This file declares templatized class SymMat for small, fixed-size symmetric matrices. More...

Go to the source code of this file.

Classes

class  SimTK::SymMat< M, ELT, RS >
 This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation. More...
 
struct  SimTK::SymMat< M, ELT, RS >::EltResult< P >
 
struct  SimTK::SymMat< M, ELT, RS >::Result< P >
 
struct  SimTK::SymMat< M, ELT, RS >::Substitute< P >
 

Namespaces

 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>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Add SimTK::operator+ (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
 
template<int M, class E1 , int S1, class E2 , int S2>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Sub SimTK::operator- (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
 
template<int M, class E1 , int S1, class E2 , int S2>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Mul SimTK::operator* (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
 
template<int M, class E1 , int S1, class E2 , int S2>
bool SimTK::operator== (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
 
template<int M, class E1 , int S1, class E2 , int S2>
bool SimTK::operator!= (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Mul SimTK::operator* (const SymMat< M, E, S > &l, const float &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Mul SimTK::operator* (const float &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Mul SimTK::operator* (const SymMat< M, E, S > &l, const double &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Mul SimTK::operator* (const double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Mul SimTK::operator* (const SymMat< M, E, S > &l, const long double &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Mul SimTK::operator* (const long double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Mul SimTK::operator* (const SymMat< M, E, S > &l, int r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Mul SimTK::operator* (int l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul SimTK::operator* (const SymMat< M, E, S > &l, const std::complex< R > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul SimTK::operator* (const std::complex< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul SimTK::operator* (const SymMat< M, E, S > &l, const conjugate< R > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul SimTK::operator* (const conjugate< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul SimTK::operator* (const SymMat< M, E, S > &l, const negator< R > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul SimTK::operator* (const negator< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, const float &r)
 
template<int M, class E , int S>
CNT< float >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (const float &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, const double &r)
 
template<int M, class E , int S>
CNT< double >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (const double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, const long double &r)
 
template<int M, class E , int S>
CNT< long double >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (const long double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, int r)
 
template<int M, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (int l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, const std::complex< R > &r)
 
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (const std::complex< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, const conjugate< R > &r)
 
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (const conjugate< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Dvd SimTK::operator/ (const SymMat< M, E, S > &l, const negator< R > &r)
 
template<int M, class E , int S, class R >
CNT< R >::template Result< SymMat< M, E, S > >::Dvd SimTK::operator/ (const negator< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Add SimTK::operator+ (const SymMat< M, E, S > &l, const float &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Add SimTK::operator+ (const float &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Add SimTK::operator+ (const SymMat< M, E, S > &l, const double &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Add SimTK::operator+ (const double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Add SimTK::operator+ (const SymMat< M, E, S > &l, const long double &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Add SimTK::operator+ (const long double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Add SimTK::operator+ (const SymMat< M, E, S > &l, int r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Add SimTK::operator+ (int l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add SimTK::operator+ (const SymMat< M, E, S > &l, const std::complex< R > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add SimTK::operator+ (const std::complex< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add SimTK::operator+ (const SymMat< M, E, S > &l, const conjugate< R > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add SimTK::operator+ (const conjugate< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Add SimTK::operator+ (const SymMat< M, E, S > &l, const negator< R > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Add SimTK::operator+ (const negator< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Sub SimTK::operator- (const SymMat< M, E, S > &l, const float &r)
 
template<int M, class E , int S>
CNT< float >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (const float &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Sub SimTK::operator- (const SymMat< M, E, S > &l, const double &r)
 
template<int M, class E , int S>
CNT< double >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (const double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Sub SimTK::operator- (const SymMat< M, E, S > &l, const long double &r)
 
template<int M, class E , int S>
CNT< long double >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (const long double &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Sub SimTK::operator- (const SymMat< M, E, S > &l, int r)
 
template<int M, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (int l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Sub SimTK::operator- (const SymMat< M, E, S > &l, const std::complex< R > &r)
 
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (const std::complex< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Sub SimTK::operator- (const SymMat< M, E, S > &l, const conjugate< R > &r)
 
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (const conjugate< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Sub SimTK::operator- (const SymMat< M, E, S > &l, const negator< R > &r)
 
template<int M, class E , int S, class R >
CNT< R >::template Result< SymMat< M, E, S > >::Sub SimTK::operator- (const negator< R > &l, const SymMat< M, E, S > &r)
 
template<int M, class E , int RS, class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > & SimTK::operator<< (std::basic_ostream< CHAR, TRAITS > &o, const SymMat< M, E, RS > &m)
 
template<int M, class E , int RS, class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > & SimTK::operator>> (std::basic_istream< CHAR, TRAITS > &is, SymMat< M, E, RS > &m)
 

Detailed Description

This file declares templatized class SymMat for small, fixed-size symmetric matrices.