Vec.h File Reference

Declaration of class Vec<NROWS, ELEMENT_TYPE, STRIDE>. More...

#include "SimTKcommon/internal/common.h"

Go to the source code of this file.

Classes
class	Vec< M, ELT, STRIDE >
	Generic Vec. More...
struct	EltResult< P >
struct	Result< P >
struct	Substitute< P >
Namespaces
namespace	SimTK
	This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols.
namespace	SimTK::Impl
Functions
template<class E1 , int S1, class E2 , int S2>
void	conformingAdd (const Vec< 1, E1, S1 > &r1, const Vec< 1, E2, S2 > &r2, Vec< 1, typename CNT< E1 >::template Result< E2 >::Add > &result)
template<int N, class E1 , int S1, class E2 , int S2>
void	conformingAdd (const Vec< N, E1, S1 > &r1, const Vec< N, E2, S2 > &r2, Vec< N, typename CNT< E1 >::template Result< E2 >::Add > &result)
template<class E1 , int S1, class E2 , int S2>
void	conformingSubtract (const Vec< 1, E1, S1 > &r1, const Vec< 1, E2, S2 > &r2, Vec< 1, typename CNT< E1 >::template Result< E2 >::Sub > &result)
template<int N, class E1 , int S1, class E2 , int S2>
void	conformingSubtract (const Vec< N, E1, S1 > &r1, const Vec< N, E2, S2 > &r2, Vec< N, typename CNT< E1 >::template Result< E2 >::Sub > &result)
template<class E1 , int S1, class E2 , int S2>
void	copy (Vec< 1, E1, S1 > &r1, const Vec< 1, E2, S2 > &r2)
template<int N, class E1 , int S1, class E2 , int S2>
void	copy (Vec< N, E1, S1 > &r1, const Vec< N, E2, S2 > &r2)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Vec< M, E2, S2 > >::Add	operator+ (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Vec< M, E2, S2 > >::Sub	operator- (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator== (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] == v2[i], for all elements i
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator!= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] != v2[i], for any element i
template<int M, class E1 , int S1, class E2 >
bool	operator== (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] == e, for all elements v[i] and element e
template<int M, class E1 , int S1, class E2 >
bool	operator!= (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] != e, for any element v[i] and element e
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator< (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] < v2[i], for all elements i
template<int M, class E1 , int S1, class E2 >
bool	operator< (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] < e, for all elements v[i] and element e
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator> (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] > v2[i], for all elements i
template<int M, class E1 , int S1, class E2 >
bool	operator> (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] > e, for all elements v[i] and element e
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator<= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] <= v2[i], for all elements i.
template<int M, class E1 , int S1, class E2 >
bool	operator<= (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] <= e, for all elements v[i] and element e.
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator>= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2).
template<int M, class E1 , int S1, class E2 >
bool	operator>= (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] >= e, for all elements v[i] and element e.
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Mul	operator* (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Mul	operator* (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Mul	operator* (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Mul	operator* (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Mul	operator* (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Mul	operator* (const long double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E > ::Precision >::Mul	operator* (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E > ::Precision >::Mul	operator* (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R > ::StdNumber >::Mul	operator* (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R > ::StdNumber >::Mul	operator* (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Dvd	operator/ (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
CNT< float >::template Result < Vec< M, E, S > >::Dvd	operator/ (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Dvd	operator/ (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
CNT< double >::template Result < Vec< M, E, S > >::Dvd	operator/ (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Dvd	operator/ (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
CNT< long double >::template Result< Vec< M, E, S > >::Dvd	operator/ (const long double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E > ::Precision >::Dvd	operator/ (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
CNT< typename CNT< E > ::Precision >::template Result < Vec< M, E, S > >::Dvd	operator/ (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Dvd	operator/ (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Dvd	operator/ (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R > ::StdNumber >::Dvd	operator/ (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
CNT< R >::template Result< Vec < M, E, S > >::Dvd	operator/ (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Add	operator+ (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Add	operator+ (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Add	operator+ (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Add	operator+ (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Add	operator+ (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Add	operator+ (const long double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E > ::Precision >::Add	operator+ (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E > ::Precision >::Add	operator+ (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R > ::StdNumber >::Add	operator+ (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R > ::StdNumber >::Add	operator+ (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Sub	operator- (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
CNT< float >::template Result < Vec< M, E, S > >::Sub	operator- (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Sub	operator- (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
CNT< double >::template Result < Vec< M, E, S > >::Sub	operator- (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Sub	operator- (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
CNT< long double >::template Result< Vec< M, E, S > >::Sub	operator- (const long double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E > ::Precision >::Sub	operator- (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
CNT< typename CNT< E > ::Precision >::template Result < Vec< M, E, S > >::Sub	operator- (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Sub	operator- (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Sub	operator- (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Sub	operator- (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Sub	operator- (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R > ::StdNumber >::Sub	operator- (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
CNT< R >::template Result< Vec < M, E, S > >::Sub	operator- (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Vec< M, E, S > &v)
template<int M, class E , int S, class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, Vec< M, E, S > &v)

---

Detailed Description

Declaration of class Vec<NROWS, ELEMENT_TYPE, STRIDE>.