Simbody  3.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Classes | Public Types | Public Member Functions | Static Public Member Functions | Related Functions | List of all members
SimTK::Row< N, ELT, STRIDE > Class Template Reference
Matrix and Vector Utilities

This is a fixed-length row vector designed for no-overhead inline computation. More...

Classes

struct  EltResult
 
struct  Result
 
struct  Substitute
 

Public Types

enum  {
  NRows = 1,
  NCols = N,
  NPackedElements = N,
  NActualElements = N * STRIDE,
  NActualScalars = CNT<E>::NActualScalars * NActualElements,
  RowSpacing = NActualElements,
  ColSpacing = STRIDE,
  ImagOffset = NTraits<ENumber>::ImagOffset,
  RealStrideFactor = 1,
  ArgDepth,
  IsScalar = 0,
  IsULessScalar = 0,
  IsNumber = 0,
  IsStdNumber = 0,
  IsPrecision = 0,
  SignInterpretation = CNT<E>::SignInterpretation
}
 
typedef Row< N, E, STRIDE > T
 
typedef Row< N, ENeg, STRIDE > TNeg
 
typedef Row< N,
EWithoutNegator, STRIDE > 		TWithoutNegator
 
typedef Row< N, EReal, STRIDE
*CNT< E >::RealStrideFactor > 		TReal
 
typedef Row< N, EImag, STRIDE
*CNT< E >::RealStrideFactor > 		TImag
 
typedef Row< N, EComplex, STRIDE > TComplex
 
typedef Vec< N, EHerm, STRIDE > THerm
 
typedef Vec< N, E, STRIDE > TPosTrans
 
typedef E TElement
 
typedef Row TRow
 
typedef E TCol
 
typedef Vec< N, ESqrt, 1 > TSqrt
 
typedef Row< N, EAbs, 1 > TAbs
 
typedef Row< N, EStandard, 1 > TStandard
 
typedef Vec< N, EInvert, 1 > TInvert
 
typedef Row< N, ENormalize, 1 > TNormalize
 
typedef SymMat< N, ESqHermT > TSqHermT
 
typedef EScalarNormSq TSqTHerm
 
typedef EScalar Scalar
 
typedef EULessScalar ULessScalar
 
typedef ENumber Number
 
typedef EStdNumber StdNumber
 
typedef EPrecision Precision
 
typedef EScalarNormSq ScalarNormSq
 

Public Member Functions

ScalarNormSq scalarNormSqr () const
 
TSqrt sqrt () const
 
TAbs abs () const
 
TStandard standardize () const
 
EStandard sum () const
 
 Row ()
 
 Row (const Row &src)
 
Row & operator= (const Row &src)
 
template<int SS>
 Row (const Row< N, E, SS > &src)
 
template<int SS>
 Row (const Row< N, ENeg, SS > &src)
 
template<class EE , int SS>
 Row (const Row< N, EE, SS > &vv)
 
 Row (const E &e)
 
 Row (const ENeg &ne)
 
 Row (int i)
 
 Row (const E &e0, const E &e1)
 
 Row (const E &e0, const E &e1, const E &e2)
 
 Row (const E &e0, const E &e1, const E &e2, const E &e3)
 
 Row (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4)
 
 Row (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)
 
 Row (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6)
 
 Row (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7)
 
 Row (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8)
 
template<class EE >
 Row (const EE *p)
 
template<class EE >
Row & operator= (const EE *p)
 
template<class EE , int SS>
Row & operator= (const Row< N, EE, SS > &vv)
 
template<class EE , int SS>
Row & operator+= (const Row< N, EE, SS > &r)
 
template<class EE , int SS>
Row & operator+= (const Row< N, negator< EE >, SS > &r)
 
template<class EE , int SS>
Row & operator-= (const Row< N, EE, SS > &r)
 
template<class EE , int SS>
Row & operator-= (const Row< N, negator< EE >, SS > &r)
 
template<class EE , int SS>
Row< N, typename CNT< E >
::template Result< EE >::Add > 		conformingAdd (const Row< N, EE, SS > &r) const
 Vector addition – use operator+ instead. More...
 
template<class EE , int SS>
Row< N, typename CNT< E >
::template Result< EE >::Sub > 		conformingSubtract (const Row< N, EE, SS > &r) const
 Vector subtraction – use operator- instead. More...
 
template<class EE , int SS>
CNT< E >::template Result< EE >
::Mul 		conformingMultiply (const Vec< N, EE, SS > &r) const
 Same as dot product (s = row*col) – use operator* or dot() instead. More...
 
template<int MatNCol, class EE , int CS, int RS>
Row< MatNCol, typename CNT< E >
::template Result< EE >::Mul > 		conformingMultiply (const Mat< N, MatNCol, EE, CS, RS > &m) const
 Row times a conforming matrix, row=row*mat – use operator* instead. More...
 
template<class EE , int SS>
Row< N, typename CNT< E >
::template Result< EE >::Mul > 		elementwiseMultiply (const Row< N, EE, SS > &r) const
 Elementwise multiply (Matlab . More...
 
template<class EE , int SS>
Row< N, typename CNT< E >
::template Result< EE >::Dvd > 		elementwiseDivide (const Row< N, EE, SS > &r) const
 Elementwise divide (Matlab . More...
 
const E & operator[] (int i) const
 
E & operator[] (int i)
 
const E & operator() (int i) const
 
E & operator() (int i)
 
ScalarNormSq normSqr () const
 
CNT< ScalarNormSq >::TSqrt norm () const
 
TNormalize normalize () const
 
TInvert invert () const
 
const Row & operator+ () const
 
const TNeg & operator- () const
 
TNeg & operator- ()
 
const THerm & operator~ () const
 
THerm & operator~ ()
 
const TNeg & negate () const
 
TNeg & updNegate ()
 
const THerm & transpose () const
 
THerm & updTranspose ()
 
const TPosTrans & positionalTranspose () const
 
TPosTrans & updPositionalTranspose ()
 
const TReal & real () const
 
TReal & real ()
 
const TImag & imag () const
 
TImag & imag ()
 
const TWithoutNegator & castAwayNegatorIfAny () const
 
TWithoutNegator & updCastAwayNegatorIfAny ()
 
template<class EE >
Row< N, typename CNT< E >
::template Result< EE >::Mul > 		scalarMultiply (const EE &e) const
 
template<class EE >
Row< N, typename CNT< EE >
::template Result< E >::Mul > 		scalarMultiplyFromLeft (const EE &e) const
 
template<class EE >
Row< N, typename CNT< E >
::template Result< EE >::Dvd > 		scalarDivide (const EE &e) const
 
template<class EE >
Row< N, typename CNT< EE >
::template Result< E >::Dvd > 		scalarDivideFromLeft (const EE &e) const
 
template<class EE >
Row< N, typename CNT< E >
::template Result< EE >::Add > 		scalarAdd (const EE &e) const
 
template<class EE >
Row< N, typename CNT< E >
::template Result< EE >::Sub > 		scalarSubtract (const EE &e) const
 
template<class EE >
Row< N, typename CNT< EE >
::template Result< E >::Sub > 		scalarSubtractFromLeft (const EE &e) const
 
template<class EE >
Row & operator= (const EE &e)
 
template<class EE >
Row & operator+= (const EE &e)
 
template<class EE >
Row & operator-= (const EE &e)
 
template<class EE >
Row & operator*= (const EE &e)
 
template<class EE >
Row & operator/= (const EE &e)
 
template<class EE >
Row & scalarEq (const EE &ee)
 
template<class EE >
Row & scalarPlusEq (const EE &ee)
 
template<class EE >
Row & scalarMinusEq (const EE &ee)
 
template<class EE >
Row & scalarMinusEqFromLeft (const EE &ee)
 
template<class EE >
Row & scalarTimesEq (const EE &ee)
 
template<class EE >
Row & scalarTimesEqFromLeft (const EE &ee)
 
template<class EE >
Row & scalarDivideEq (const EE &ee)
 
template<class EE >
Row & scalarDivideEqFromLeft (const EE &ee)
 
Row & scalarEq (int ee)
 
Row & scalarPlusEq (int ee)
 
Row & scalarMinusEq (int ee)
 
Row & scalarTimesEq (int ee)
 
Row & scalarDivideEq (int ee)
 
Row & scalarMinusEqFromLeft (int ee)
 
Row & scalarTimesEqFromLeft (int ee)
 
Row & scalarDivideEqFromLeft (int ee)
 
void setToNaN ()
 Set every scalar in this Row to NaN; this is the default initial value in Debug builds, but not in Release. More...
 
void setToZero ()
 Set every scalar in this Row to zero. More...
 
template<int NN>
const Row< NN, ELT, STRIDE > & getSubRow (int j) const
 Extract a const reference to a sub-Row with size known at compile time. More...
 
template<int NN>
Row< NN, ELT, STRIDE > & updSubRow (int j)
 Extract a writable reference to a sub-Row with size known at compile time. More...
 
Row< N-1, ELT, 1 > drop1 (int p) const
 Return a row one smaller than this one by dropping the element at the indicated position p. More...
 
template<class EE >
Row< N+1, ELT, 1 > append1 (const EE &v) const
 Return a row one larger than this one by adding an element to the end. More...
 
template<class EE >
Row< N+1, ELT, 1 > insert1 (int p, const EE &v) const
 Return a row one larger than this one by inserting an element before the indicated one. More...
 
bool isNaN () const
 Return true if any element of this Row contains a NaN anywhere. More...
 
bool isInf () const
 Return true if any element of this Row contains a +Infinity or -Infinity somewhere but no element contains a NaN anywhere. More...
 
bool isFinite () const
 Return true if no element of this Row contains an Infinity or a NaN anywhere. More...
 
template<class E2 , int CS2>
bool isNumericallyEqual (const Row< N, E2, CS2 > &r, double tol) const
 Test whether this row is numerically equal to some other row with the same shape, using a specified tolerance. More...
 
template<class E2 , int CS2>
bool isNumericallyEqual (const Row< N, E2, CS2 > &r) const
 Test whether this row vector is numerically equal to some other row with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared. More...
 
bool isNumericallyEqual (const ELT &e, double tol=getDefaultTolerance()) const
 Test whether every element of this row vector is numerically equal to the given element, using either a specified tolerance or the row's default tolerance (which is always the same or looser than the default tolerance for one of its elements). More...
 

Static Public Member Functions

static int size ()
 
static int nrow ()
 
static int ncol ()
 
template<int NN>
static const Row & getSubRow (const Row< NN, ELT, STRIDE > &r, int j)
 Extract a subvector of type Row from a longer one that has the same element type and stride, and return a const reference to the selected subsequence. More...
 
template<int NN>
static Row & updSubRow (Row< NN, ELT, STRIDE > &r, int j)
 Extract a subvector of type Row from a longer one that has the same element type and stride, and return a writable reference to the selected subsequence. More...
 
static const Row & getAs (const ELT *p)
 Recast an ordinary C++ array E[] to a const Row<N,E,S>; assumes compatible length, stride, and packing. More...
 
static Row & updAs (ELT *p)
 Recast a writable ordinary C++ array E[] to a writable Row<N,E,S>; assumes compatible length, stride, and packing. More...
 
static Row< N, ELT, 1 > getNaN ()
 Return a Row of the same length and element type as this one but with all elements set to NaN. More...
 
static double getDefaultTolerance ()
 For approximate comparisions, the default tolerance to use for a vector is the same as its elements' default tolerance. More...
 

Related Functions

(Note that these are not member functions.)

template<int N, class E , int S>
void writeUnformatted (std::ostream &o, const Row< N, E, S > &v)
 Specialize for Row<N,E,S> to delegate to element type E, with spaces separating the elements; raw output is same as Vec. More...
 
template<int N, class E , int S>
bool readUnformatted (std::istream &in, Row< N, E, S > &v)
 Specialize for Row<N,E,S> to delegate to element type E, with spaces separating the elements; format is same as Vec. More...
 

Detailed Description

template<int N, class ELT, int STRIDE>
class SimTK::Row< N, ELT, STRIDE >

This is a fixed-length row vector designed for no-overhead inline computation.

The Row type is not commonly used in Simbody user programs; the column vector class Vec is much more common. Typically Row objects arise either from transposing a Vec or selecting rows from a Mat.

Template Parameters
NThe number of columns in the row vector.
ELTThe element type. Must be a composite numerical type (CNT). The default is ELT=Real.
STRIDEThe spacing from one element to the next in memory, as an integer number of elements of type ELT. The default is STRIDE=1.

Member Typedef Documentation

template<int N, class ELT, int STRIDE>
typedef Row<N,E,STRIDE> SimTK::Row< N, ELT, STRIDE >::T
template<int N, class ELT, int STRIDE>
typedef Row<N,ENeg,STRIDE> SimTK::Row< N, ELT, STRIDE >::TNeg
template<int N, class ELT, int STRIDE>
typedef Row<N,EWithoutNegator,STRIDE> SimTK::Row< N, ELT, STRIDE >::TWithoutNegator
template<int N, class ELT, int STRIDE>
typedef Row<N,EReal,STRIDE*CNT<E>::RealStrideFactor> SimTK::Row< N, ELT, STRIDE >::TReal
template<int N, class ELT, int STRIDE>
typedef Row<N,EImag,STRIDE*CNT<E>::RealStrideFactor> SimTK::Row< N, ELT, STRIDE >::TImag
template<int N, class ELT, int STRIDE>
typedef Row<N,EComplex,STRIDE> SimTK::Row< N, ELT, STRIDE >::TComplex
template<int N, class ELT, int STRIDE>
typedef Vec<N,EHerm,STRIDE> SimTK::Row< N, ELT, STRIDE >::THerm
template<int N, class ELT, int STRIDE>
typedef Vec<N,E,STRIDE> SimTK::Row< N, ELT, STRIDE >::TPosTrans
template<int N, class ELT, int STRIDE>
typedef E SimTK::Row< N, ELT, STRIDE >::TElement
template<int N, class ELT, int STRIDE>
typedef Row SimTK::Row< N, ELT, STRIDE >::TRow
template<int N, class ELT, int STRIDE>
typedef E SimTK::Row< N, ELT, STRIDE >::TCol
template<int N, class ELT, int STRIDE>
typedef Vec<N,ESqrt,1> SimTK::Row< N, ELT, STRIDE >::TSqrt
template<int N, class ELT, int STRIDE>
typedef Row<N,EAbs,1> SimTK::Row< N, ELT, STRIDE >::TAbs
template<int N, class ELT, int STRIDE>
typedef Row<N,EStandard,1> SimTK::Row< N, ELT, STRIDE >::TStandard
template<int N, class ELT, int STRIDE>
typedef Vec<N,EInvert,1> SimTK::Row< N, ELT, STRIDE >::TInvert
template<int N, class ELT, int STRIDE>
typedef Row<N,ENormalize,1> SimTK::Row< N, ELT, STRIDE >::TNormalize
template<int N, class ELT, int STRIDE>
typedef SymMat<N,ESqHermT> SimTK::Row< N, ELT, STRIDE >::TSqHermT
template<int N, class ELT, int STRIDE>
typedef EScalarNormSq SimTK::Row< N, ELT, STRIDE >::TSqTHerm
template<int N, class ELT, int STRIDE>
typedef EScalar SimTK::Row< N, ELT, STRIDE >::Scalar
template<int N, class ELT, int STRIDE>
typedef EULessScalar SimTK::Row< N, ELT, STRIDE >::ULessScalar
template<int N, class ELT, int STRIDE>
typedef ENumber SimTK::Row< N, ELT, STRIDE >::Number
template<int N, class ELT, int STRIDE>
typedef EStdNumber SimTK::Row< N, ELT, STRIDE >::StdNumber
template<int N, class ELT, int STRIDE>
typedef EPrecision SimTK::Row< N, ELT, STRIDE >::Precision
template<int N, class ELT, int STRIDE>
typedef EScalarNormSq SimTK::Row< N, ELT, STRIDE >::ScalarNormSq

Constructor & Destructor Documentation

template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( )
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const Row< N, ELT, STRIDE > &  src)
inline
template<int N, class ELT, int STRIDE>
template<int SS>
SimTK::Row< N, ELT, STRIDE >::Row ( const Row< N, E, SS > &  src)
inline
template<int N, class ELT, int STRIDE>
template<int SS>
SimTK::Row< N, ELT, STRIDE >::Row ( const Row< N, ENeg, SS > &  src)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
SimTK::Row< N, ELT, STRIDE >::Row ( const Row< N, EE, SS > &  vv)
inlineexplicit
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e)
inlineexplicit
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const ENeg &  ne)
inlineexplicit
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( int  i)
inlineexplicit
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7 
)
inline
template<int N, class ELT, int STRIDE>
SimTK::Row< N, ELT, STRIDE >::Row ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8 
)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
SimTK::Row< N, ELT, STRIDE >::Row ( const EE *  p)
inlineexplicit

Member Function Documentation

template<int N, class ELT, int STRIDE>
static int SimTK::Row< N, ELT, STRIDE >::size ( )
inlinestatic
template<int N, class ELT, int STRIDE>
static int SimTK::Row< N, ELT, STRIDE >::nrow ( )
inlinestatic
template<int N, class ELT, int STRIDE>
static int SimTK::Row< N, ELT, STRIDE >::ncol ( )
inlinestatic
template<int N, class ELT, int STRIDE>
ScalarNormSq SimTK::Row< N, ELT, STRIDE >::scalarNormSqr ( ) const
inline
template<int N, class ELT, int STRIDE>
TSqrt SimTK::Row< N, ELT, STRIDE >::sqrt ( ) const
inline
template<int N, class ELT, int STRIDE>
TAbs SimTK::Row< N, ELT, STRIDE >::abs ( ) const
inline
template<int N, class ELT, int STRIDE>
TStandard SimTK::Row< N, ELT, STRIDE >::standardize ( ) const
inline
template<int N, class ELT, int STRIDE>
EStandard SimTK::Row< N, ELT, STRIDE >::sum ( ) const
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::operator= ( const Row< N, ELT, STRIDE > &  src)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::operator= ( const EE *  p)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row& SimTK::Row< N, ELT, STRIDE >::operator= ( const Row< N, EE, SS > &  vv)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row& SimTK::Row< N, ELT, STRIDE >::operator+= ( const Row< N, EE, SS > &  r)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row& SimTK::Row< N, ELT, STRIDE >::operator+= ( const Row< N, negator< EE >, SS > &  r)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row& SimTK::Row< N, ELT, STRIDE >::operator-= ( const Row< N, EE, SS > &  r)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row& SimTK::Row< N, ELT, STRIDE >::operator-= ( const Row< N, negator< EE >, SS > &  r)
inline
template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row<N,typename CNT<E>::template Result<EE>::Add> SimTK::Row< N, ELT, STRIDE >::conformingAdd ( const Row< N, EE, SS > &  r) const
inline

Vector addition – use operator+ instead.

template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row<N,typename CNT<E>::template Result<EE>::Sub> SimTK::Row< N, ELT, STRIDE >::conformingSubtract ( const Row< N, EE, SS > &  r) const
inline

Vector subtraction – use operator- instead.

template<int N, class ELT, int STRIDE>
template<class EE , int SS>
CNT<E>::template Result<EE>::Mul SimTK::Row< N, ELT, STRIDE >::conformingMultiply ( const Vec< N, EE, SS > &  r) const
inline

Same as dot product (s = row*col) – use operator* or dot() instead.

template<int N, class ELT, int STRIDE>
template<int MatNCol, class EE , int CS, int RS>
Row<MatNCol,typename CNT<E>::template Result<EE>::Mul> SimTK::Row< N, ELT, STRIDE >::conformingMultiply ( const Mat< N, MatNCol, EE, CS, RS > &  m) const
inline

Row times a conforming matrix, row=row*mat – use operator* instead.

template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row<N,typename CNT<E>::template Result<EE>::Mul> SimTK::Row< N, ELT, STRIDE >::elementwiseMultiply ( const Row< N, EE, SS > &  r) const
inline

Elementwise multiply (Matlab .

* operator).

template<int N, class ELT, int STRIDE>
template<class EE , int SS>
Row<N,typename CNT<E>::template Result<EE>::Dvd> SimTK::Row< N, ELT, STRIDE >::elementwiseDivide ( const Row< N, EE, SS > &  r) const
inline

Elementwise divide (Matlab .

/ operator).

template<int N, class ELT, int STRIDE>
const E& SimTK::Row< N, ELT, STRIDE >::operator[] ( int  i) const
inline
template<int N, class ELT, int STRIDE>
E& SimTK::Row< N, ELT, STRIDE >::operator[] ( int  i)
inline
template<int N, class ELT, int STRIDE>
const E& SimTK::Row< N, ELT, STRIDE >::operator() ( int  i) const
inline
template<int N, class ELT, int STRIDE>
E& SimTK::Row< N, ELT, STRIDE >::operator() ( int  i)
inline
template<int N, class ELT, int STRIDE>
ScalarNormSq SimTK::Row< N, ELT, STRIDE >::normSqr ( ) const
inline
template<int N, class ELT, int STRIDE>
CNT<ScalarNormSq>::TSqrt SimTK::Row< N, ELT, STRIDE >::norm ( ) const
inline
template<int N, class ELT, int STRIDE>
TNormalize SimTK::Row< N, ELT, STRIDE >::normalize ( ) const
inline
template<int N, class ELT, int STRIDE>
TInvert SimTK::Row< N, ELT, STRIDE >::invert ( ) const
inline
template<int N, class ELT, int STRIDE>
const Row& SimTK::Row< N, ELT, STRIDE >::operator+ ( ) const
inline
template<int N, class ELT, int STRIDE>
const TNeg& SimTK::Row< N, ELT, STRIDE >::operator- ( ) const
inline
template<int N, class ELT, int STRIDE>
TNeg& SimTK::Row< N, ELT, STRIDE >::operator- ( )
inline
template<int N, class ELT, int STRIDE>
const THerm& SimTK::Row< N, ELT, STRIDE >::operator~ ( ) const
inline
template<int N, class ELT, int STRIDE>
THerm& SimTK::Row< N, ELT, STRIDE >::operator~ ( )
inline
template<int N, class ELT, int STRIDE>
const TNeg& SimTK::Row< N, ELT, STRIDE >::negate ( ) const
inline
template<int N, class ELT, int STRIDE>
TNeg& SimTK::Row< N, ELT, STRIDE >::updNegate ( )
inline
template<int N, class ELT, int STRIDE>
const THerm& SimTK::Row< N, ELT, STRIDE >::transpose ( ) const
inline
template<int N, class ELT, int STRIDE>
THerm& SimTK::Row< N, ELT, STRIDE >::updTranspose ( )
inline
template<int N, class ELT, int STRIDE>
const TPosTrans& SimTK::Row< N, ELT, STRIDE >::positionalTranspose ( ) const
inline
template<int N, class ELT, int STRIDE>
TPosTrans& SimTK::Row< N, ELT, STRIDE >::updPositionalTranspose ( )
inline
template<int N, class ELT, int STRIDE>
const TReal& SimTK::Row< N, ELT, STRIDE >::real ( ) const
inline
template<int N, class ELT, int STRIDE>
TReal& SimTK::Row< N, ELT, STRIDE >::real ( )
inline
template<int N, class ELT, int STRIDE>
const TImag& SimTK::Row< N, ELT, STRIDE >::imag ( ) const
inline
template<int N, class ELT, int STRIDE>
TImag& SimTK::Row< N, ELT, STRIDE >::imag ( )
inline
template<int N, class ELT, int STRIDE>
const TWithoutNegator& SimTK::Row< N, ELT, STRIDE >::castAwayNegatorIfAny ( ) const
inline
template<int N, class ELT, int STRIDE>
TWithoutNegator& SimTK::Row< N, ELT, STRIDE >::updCastAwayNegatorIfAny ( )
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<E>::template Result<EE>::Mul> SimTK::Row< N, ELT, STRIDE >::scalarMultiply ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<EE>::template Result<E>::Mul> SimTK::Row< N, ELT, STRIDE >::scalarMultiplyFromLeft ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<E>::template Result<EE>::Dvd> SimTK::Row< N, ELT, STRIDE >::scalarDivide ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<EE>::template Result<E>::Dvd> SimTK::Row< N, ELT, STRIDE >::scalarDivideFromLeft ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<E>::template Result<EE>::Add> SimTK::Row< N, ELT, STRIDE >::scalarAdd ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<E>::template Result<EE>::Sub> SimTK::Row< N, ELT, STRIDE >::scalarSubtract ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row<N, typename CNT<EE>::template Result<E>::Sub> SimTK::Row< N, ELT, STRIDE >::scalarSubtractFromLeft ( const EE &  e) const
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::operator= ( const EE &  e)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::operator+= ( const EE &  e)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::operator-= ( const EE &  e)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::operator*= ( const EE &  e)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::operator/= ( const EE &  e)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarEq ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarPlusEq ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarMinusEq ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarMinusEqFromLeft ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarTimesEq ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarTimesEqFromLeft ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarDivideEq ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
template<class EE >
Row& SimTK::Row< N, ELT, STRIDE >::scalarDivideEqFromLeft ( const EE &  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarEq ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarPlusEq ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarMinusEq ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarTimesEq ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarDivideEq ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarMinusEqFromLeft ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarTimesEqFromLeft ( int  ee)
inline
template<int N, class ELT, int STRIDE>
Row& SimTK::Row< N, ELT, STRIDE >::scalarDivideEqFromLeft ( int  ee)
inline
template<int N, class ELT, int STRIDE>
void SimTK::Row< N, ELT, STRIDE >::setToNaN ( )
inline

Set every scalar in this Row to NaN; this is the default initial value in Debug builds, but not in Release.

template<int N, class ELT, int STRIDE>
void SimTK::Row< N, ELT, STRIDE >::setToZero ( )
inline

Set every scalar in this Row to zero.

template<int N, class ELT, int STRIDE>
template<int NN>
const Row<NN,ELT,STRIDE>& SimTK::Row< N, ELT, STRIDE >::getSubRow ( int  j) const
inline

Extract a const reference to a sub-Row with size known at compile time.

This must be called with an explicit template argument for the size, for example, getSubRow<3>(j). This is only a recast; no copying or computation is performed. The size and index are range checked in Debug builds but not in Release builds.

template<int N, class ELT, int STRIDE>
template<int NN>
Row<NN,ELT,STRIDE>& SimTK::Row< N, ELT, STRIDE >::updSubRow ( int  j)
inline

Extract a writable reference to a sub-Row with size known at compile time.

This must be called with an explicit template argument for the size, for example, updSubRow<3>(j). This is only a recast; no copying or computation is performed. The size and index are range checked in Debug builds but not in Release builds.

template<int N, class ELT, int STRIDE>
template<int NN>
static const Row& SimTK::Row< N, ELT, STRIDE >::getSubRow ( const Row< NN, ELT, STRIDE > &  r,
int  j 
)
inlinestatic

Extract a subvector of type Row from a longer one that has the same element type and stride, and return a const reference to the selected subsequence.

template<int N, class ELT, int STRIDE>
template<int NN>
static Row& SimTK::Row< N, ELT, STRIDE >::updSubRow ( Row< NN, ELT, STRIDE > &  r,
int  j 
)
inlinestatic

Extract a subvector of type Row from a longer one that has the same element type and stride, and return a writable reference to the selected subsequence.

template<int N, class ELT, int STRIDE>
Row<N-1,ELT,1> SimTK::Row< N, ELT, STRIDE >::drop1 ( int  p) const
inline

Return a row one smaller than this one by dropping the element at the indicated position p.

The result is a packed copy with the same element type as this one.

template<int N, class ELT, int STRIDE>
template<class EE >
Row<N+1,ELT,1> SimTK::Row< N, ELT, STRIDE >::append1 ( const EE &  v) const
inline

Return a row one larger than this one by adding an element to the end.

The result is a packed copy with the same element type as this one. Works for any assignment compatible element.

template<int N, class ELT, int STRIDE>
template<class EE >
Row<N+1,ELT,1> SimTK::Row< N, ELT, STRIDE >::insert1 ( int  p,
const EE &  v 
) const
inline

Return a row one larger than this one by inserting an element before the indicated one.

The result is a packed copy with the same element type as this one. Works for any assignment compatible element. The index can be one greater than normally allowed in which case the element is appended (but use append1() if you know you're appending).

template<int N, class ELT, int STRIDE>
static const Row& SimTK::Row< N, ELT, STRIDE >::getAs ( const ELT *  p)
inlinestatic

Recast an ordinary C++ array E[] to a const Row<N,E,S>; assumes compatible length, stride, and packing.

template<int N, class ELT, int STRIDE>
static Row& SimTK::Row< N, ELT, STRIDE >::updAs ( ELT *  p)
inlinestatic

Recast a writable ordinary C++ array E[] to a writable Row<N,E,S>; assumes compatible length, stride, and packing.

template<int N, class ELT, int STRIDE>
static Row<N,ELT,1> SimTK::Row< N, ELT, STRIDE >::getNaN ( )
inlinestatic

Return a Row of the same length and element type as this one but with all elements set to NaN.

The result is packed (stride==1) regardless of the stride of this Row.

template<int N, class ELT, int STRIDE>
bool SimTK::Row< N, ELT, STRIDE >::isNaN ( ) const
inline

Return true if any element of this Row contains a NaN anywhere.

template<int N, class ELT, int STRIDE>
bool SimTK::Row< N, ELT, STRIDE >::isInf ( ) const
inline

Return true if any element of this Row contains a +Infinity or -Infinity somewhere but no element contains a NaN anywhere.

template<int N, class ELT, int STRIDE>
bool SimTK::Row< N, ELT, STRIDE >::isFinite ( ) const
inline

Return true if no element of this Row contains an Infinity or a NaN anywhere.

template<int N, class ELT, int STRIDE>
static double SimTK::Row< N, ELT, STRIDE >::getDefaultTolerance ( )
inlinestatic

For approximate comparisions, the default tolerance to use for a vector is the same as its elements' default tolerance.

template<int N, class ELT, int STRIDE>
template<class E2 , int CS2>
bool SimTK::Row< N, ELT, STRIDE >::isNumericallyEqual ( const Row< N, E2, CS2 > &  r,
double  tol 
) const
inline

Test whether this row is numerically equal to some other row with the same shape, using a specified tolerance.

template<int N, class ELT, int STRIDE>
template<class E2 , int CS2>
bool SimTK::Row< N, ELT, STRIDE >::isNumericallyEqual ( const Row< N, E2, CS2 > &  r) const
inline

Test whether this row vector is numerically equal to some other row with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared.

template<int N, class ELT, int STRIDE>
bool SimTK::Row< N, ELT, STRIDE >::isNumericallyEqual ( const ELT &  e,
double  tol = getDefaultTolerance() 
) const
inline

Test whether every element of this row vector is numerically equal to the given element, using either a specified tolerance or the row's default tolerance (which is always the same or looser than the default tolerance for one of its elements).

The documentation for this class was generated from the following files: