Simbody  3.6
SimTK::VectorBase< ELT > Class Template Reference

This is a dataless rehash of the MatrixBase class to specialize it for Vectors. More...

Classes

struct  EltResult
 

Public Member Functions

VectorBaseoperator= (const VectorBase &b)
 Copy assignment is deep copy but behavior depends on type of lhs: if view, rhs must match. More...
 
VectorBaseoperator*= (const StdNumber &t)
 
VectorBaseoperator/= (const StdNumber &t)
 
VectorBaseoperator+= (const VectorBase &r)
 
VectorBaseoperator-= (const VectorBase &r)
 
template<class EE >
VectorBaseoperator= (const VectorBase< EE > &b)
 
template<class EE >
VectorBaseoperator+= (const VectorBase< EE > &b)
 
template<class EE >
VectorBaseoperator-= (const VectorBase< EE > &b)
 
VectorBaseoperator= (const ELT &t)
 Fill current allocation with copies of element. More...
 
template<class EE >
VectorBaserowScaleInPlace (const VectorBase< EE > &v)
 There's only one column here so it's a bit weird to use rowScale rather than elementwiseMultiply, but there's nothing really wrong with it. More...
 
template<class EE >
void rowScale (const VectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
 
template<class EE >
EltResult< EE >::Mul rowScale (const VectorBase< EE > &v) const
 
CNT< ScalarNormSq >::TSqrt normRMS (int *worstOne=0) const
 Return the root-mean-square (RMS) norm of a Vector of scalars, with optional return of the index of the element of largest absolute value. More...
 
template<class EE >
CNT< ScalarNormSq >::TSqrt weightedNormRMS (const VectorBase< EE > &w, int *worstOne=0) const
 Return the weighted root-mean-square (WRMS) norm of a Vector of scalars, with optional return of the index of the weighted element of largest absolute value. More...
 
EAbs normInf (int *worstOne=0) const
 Return the infinity norm (max absolute value) of a Vector of scalars, with optional return of the index of the element of largest absolute value. More...
 
template<class EE >
EAbs weightedNormInf (const VectorBase< EE > &w, int *worstOne=0) const
 Return the weighted infinity norm (max absolute value) WInf of a Vector of scalars, with optional return of the index of the weighted element of largest absolute value. More...
 
VectorBaseelementwiseInvertInPlace ()
 Set this[i] = this[i]^-1. More...
 
void elementwiseInvert (VectorBase< typename CNT< ELT >::TInvert > &out) const
 Set supplied out[i] = this[i]^-1. More...
 
VectorBase< typename CNT< ELT >::TInvert > elementwiseInvert () const
 Return out[i]=this[i]^-1 as function return. More...
 
template<class EE >
VectorBaseelementwiseMultiplyInPlace (const VectorBase< EE > &r)
 
template<class EE >
void elementwiseMultiply (const VectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
 
template<class EE >
EltResult< EE >::Mul elementwiseMultiply (const VectorBase< EE > &v) const
 
template<class EE >
VectorBaseelementwiseMultiplyFromLeftInPlace (const VectorBase< EE > &r)
 
template<class EE >
void elementwiseMultiplyFromLeft (const VectorBase< EE > &v, typename VectorBase< EE >::template EltResult< ELT >::Mul &out) const
 
template<class EE >
VectorBase< EE >::template EltResult< ELT >::Mul elementwiseMultiplyFromLeft (const VectorBase< EE > &v) const
 
template<class EE >
VectorBaseelementwiseDivideInPlace (const VectorBase< EE > &r)
 
template<class EE >
void elementwiseDivide (const VectorBase< EE > &v, typename EltResult< EE >::Dvd &out) const
 
template<class EE >
EltResult< EE >::Dvd elementwiseDivide (const VectorBase< EE > &v) const
 
template<class EE >
VectorBaseelementwiseDivideFromLeftInPlace (const VectorBase< EE > &r)
 
template<class EE >
void elementwiseDivideFromLeft (const VectorBase< EE > &v, typename VectorBase< EE >::template EltResult< ELT >::Dvd &out) const
 
template<class EE >
VectorBase< EE >::template EltResult< ELT >::Dvd elementwiseDivideFromLeft (const VectorBase< EE > &v) const
 
 operator const Vector_< ELT > & () const
 
 operator Vector_< ELT > & ()
 
 operator const VectorView_< ELT > & () const
 
 operator VectorView_< ELT > & ()
 
 operator const Matrix_< ELT > & () const
 
 operator Matrix_< ELT > & ()
 
 operator const MatrixView_< ELT > & () const
 
 operator MatrixView_< ELT > & ()
 
int size () const
 
int nrow () const
 
int ncol () const
 
ptrdiff_t nelt () const
 
TAbs abs () const
 
const ELT & operator[] (int i) const
 
ELT & operator[] (int i)
 
const ELT & operator() (int i) const
 
ELT & operator() (int i)
 
VectorView_< ELT > operator() (int i, int m) const
 
VectorView_< ELT > operator() (int i, int m)
 
VectorView_< ELT > index (const Array_< int > &indices) const
 
VectorView_< ELT > updIndex (const Array_< int > &indices)
 
VectorView_< ELT > operator() (const Array_< int > &indices) const
 
VectorView_< ELT > operator() (const Array_< int > &indices)
 
THerm transpose () const
 
THerm updTranspose ()
 
THerm operator~ () const
 
THerm operator~ ()
 
const VectorBaseoperator+ () const
 
const TNegnegate () const
 
TNegupdNegate ()
 
const TNegoperator- () const
 
TNegoperator- ()
 
VectorBaseresize (int m)
 
VectorBaseresizeKeep (int m)
 
void clear ()
 
ELT sum () const
 
VectorIterator< ELT, VectorBase< ELT > > begin ()
 
VectorIterator< ELT, VectorBase< ELT > > end ()
 
VectorBase "owner" construction

These constructors create new VectorBase objects which own their own data and are (at least by default) resizable.

The resulting matrices are m X 1 with the number of columns locked at 1. If there is any data allocated but not explicitly initialized, that data will be uninitialized garbage in Release builds but will be initialized to NaN (at a performance cost) in Debug builds.

 VectorBase (int m=0)
 Default constructor makes a 0x1 matrix locked at 1 column; you can provide an initial allocation if you want. More...
 
 VectorBase (const VectorBase &source)
 Copy constructor is a deep copy (not appropriate for views!). More...
 
 VectorBase (const TNeg &source)
 Implicit conversion from compatible vector with negated elements. More...
 
 VectorBase (int m, const ELT &initialValue)
 Construct an owner vector of length m, with each element initialized to the given value. More...
 
 VectorBase (int m, const ELT *cppInitialValues)
 Construct an owner vector of length m, with the elements initialized sequentially from a C++ array of elements which is assumed to be of length m. More...
 
VectorBase construction from pre-existing data

Construct a non-resizeable, VectorBase view of externally supplied data.

Note that stride should be interpreted as "the number of scalars between elements" and for composite elements may have a different value if the source is a C++ array of elements vs. a Simmatrix packed data array. We provide constructors for both read-only and writable external data.

 VectorBase (int m, int stride, const Scalar *s)
 Construct a read-only view of existing data. More...
 
 VectorBase (int m, int stride, Scalar *s)
 Construct a writable view into existing data. More...
 
VectorBase construction from an existing Helper.

Create a new VectorBase from an existing helper.

Both shallow (view) and deep copies are possible. For shallow copies, there is a constructor providing a read-only view of the original data and one providing a writable view into the original data.

 VectorBase (MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
 Construct a writable view into the source data. More...
 
 VectorBase (const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
 Construct a read-only view of the source data. More...
 
 VectorBase (const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::DeepCopy &d)
 Construct a new owner vector initialized with the data from the source. More...
 

Protected Member Functions

 VectorBase (MatrixHelperRep< Scalar > *hrep)
 

Related Functions

(Note that these are not member functions.)

Matrix_<T> serialization and I/O

These methods are at namespace scope but are logically part of the Vector classes.

These deal with reading and writing Vectors from and to streams, which places an additional requirement on the element type T: the element must support the same operation you are trying to do on the Vector as a whole.

template<class E >
void writeUnformatted (std::ostream &o, const VectorBase< E > &v)
 Specialize for VectorBase<E> to delegate to element type E, with spaces separating the elements. More...
 

Detailed Description

template<class ELT>
class SimTK::VectorBase< ELT >

This is a dataless rehash of the MatrixBase class to specialize it for Vectors.

This mostly entails overriding a few of the methods. Note that all the MatrixBase operations remain available if you static_cast this up to a MatrixBase.

Constructor & Destructor Documentation

◆ VectorBase() [1/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( int  m = 0)
inlineexplicit

Default constructor makes a 0x1 matrix locked at 1 column; you can provide an initial allocation if you want.

◆ VectorBase() [2/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( const VectorBase< ELT > &  source)
inline

Copy constructor is a deep copy (not appropriate for views!).

That means it creates a new, densely packed vector whose elements are initialized from the source object.

◆ VectorBase() [3/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( const TNeg source)
inline

Implicit conversion from compatible vector with negated elements.

◆ VectorBase() [4/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( int  m,
const ELT &  initialValue 
)
inline

Construct an owner vector of length m, with each element initialized to the given value.

◆ VectorBase() [5/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( int  m,
const ELT *  cppInitialValues 
)
inline

Construct an owner vector of length m, with the elements initialized sequentially from a C++ array of elements which is assumed to be of length m.

Note that we are expecting C++ packing; don't use this to initialize one Simmatrix vector from another because Simmatrix may pack its elements more densely than C++.

◆ VectorBase() [6/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( int  m,
int  stride,
const Scalar *  s 
)
inline

Construct a read-only view of existing data.

◆ VectorBase() [7/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( int  m,
int  stride,
Scalar *  s 
)
inline

Construct a writable view into existing data.

◆ VectorBase() [8/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( MatrixHelper< Scalar > &  h,
const typename MatrixHelper< Scalar >::ShallowCopy &  s 
)
inline

Construct a writable view into the source data.

◆ VectorBase() [9/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( const MatrixHelper< Scalar > &  h,
const typename MatrixHelper< Scalar >::ShallowCopy &  s 
)
inline

Construct a read-only view of the source data.

◆ VectorBase() [10/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( const MatrixHelper< Scalar > &  h,
const typename MatrixHelper< Scalar >::DeepCopy &  d 
)
inline

Construct a new owner vector initialized with the data from the source.

◆ VectorBase() [11/11]

template<class ELT >
SimTK::VectorBase< ELT >::VectorBase ( MatrixHelperRep< Scalar > *  hrep)
inlineexplicitprotected

Member Function Documentation

◆ operator=() [1/3]

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::operator= ( const VectorBase< ELT > &  b)
inline

Copy assignment is deep copy but behavior depends on type of lhs: if view, rhs must match.

If owner, we reallocate and copy rhs.

◆ operator*=()

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::operator*= ( const StdNumber &  t)
inline

◆ operator/=()

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::operator/= ( const StdNumber &  t)
inline

◆ operator+=() [1/2]

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::operator+= ( const VectorBase< ELT > &  r)
inline

◆ operator-=() [1/2]

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::operator-= ( const VectorBase< ELT > &  r)
inline

◆ operator=() [2/3]

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::operator= ( const VectorBase< EE > &  b)
inline

◆ operator+=() [2/2]

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::operator+= ( const VectorBase< EE > &  b)
inline

◆ operator-=() [2/2]

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::operator-= ( const VectorBase< EE > &  b)
inline

◆ operator=() [3/3]

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::operator= ( const ELT &  t)
inline

Fill current allocation with copies of element.

Note that this is not the same behavior as assignment for Matrices, where only the diagonal is set (and everything else is set to zero.)

◆ rowScaleInPlace()

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::rowScaleInPlace ( const VectorBase< EE > &  v)
inline

There's only one column here so it's a bit weird to use rowScale rather than elementwiseMultiply, but there's nothing really wrong with it.

Using colScale would be really wacky since it is the same as a scalar multiply. We won't support colScale here except through inheritance where it will not be much use.

◆ rowScale() [1/2]

template<class ELT >
template<class EE >
void SimTK::VectorBase< ELT >::rowScale ( const VectorBase< EE > &  v,
typename EltResult< EE >::Mul &  out 
) const
inline

◆ rowScale() [2/2]

template<class ELT >
template<class EE >
EltResult<EE>::Mul SimTK::VectorBase< ELT >::rowScale ( const VectorBase< EE > &  v) const
inline

◆ normRMS()

template<class ELT >
CNT<ScalarNormSq>::TSqrt SimTK::VectorBase< ELT >::normRMS ( int *  worstOne = 0) const
inline

Return the root-mean-square (RMS) norm of a Vector of scalars, with optional return of the index of the element of largest absolute value.

The RMS norm of a Vector v of length n is rms=sqrt(~v*v/n). If n==0 we define the RMS norm to be zero but return the element index as -1.

◆ weightedNormRMS()

template<class ELT >
template<class EE >
CNT<ScalarNormSq>::TSqrt SimTK::VectorBase< ELT >::weightedNormRMS ( const VectorBase< EE > &  w,
int *  worstOne = 0 
) const
inline

Return the weighted root-mean-square (WRMS) norm of a Vector of scalars, with optional return of the index of the weighted element of largest absolute value.

The WRMS norm of a Vector v of length n with weights w is wrms=sqrt(sum_i((w_i*v_i)^2))/n). If n==0 we define the WRMS norm to be zero but return the element index as -1.

◆ normInf()

template<class ELT >
EAbs SimTK::VectorBase< ELT >::normInf ( int *  worstOne = 0) const
inline

Return the infinity norm (max absolute value) of a Vector of scalars, with optional return of the index of the element of largest absolute value.

The Inf norm of a Vector v is inf=max_i(|v_i|). If n==0 we define the Inf norm to be zero but return the element index as -1.

◆ weightedNormInf()

template<class ELT >
template<class EE >
EAbs SimTK::VectorBase< ELT >::weightedNormInf ( const VectorBase< EE > &  w,
int *  worstOne = 0 
) const
inline

Return the weighted infinity norm (max absolute value) WInf of a Vector of scalars, with optional return of the index of the weighted element of largest absolute value.

The WInf norm of a Vector v of length n with weights w is winf=max_i(|w_i*v_i|). If n==0 we define the WInf norm to be zero but return the element index as -1.

◆ elementwiseInvertInPlace()

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::elementwiseInvertInPlace ( )
inline

Set this[i] = this[i]^-1.

◆ elementwiseInvert() [1/2]

template<class ELT >
void SimTK::VectorBase< ELT >::elementwiseInvert ( VectorBase< typename CNT< ELT >::TInvert > &  out) const
inline

Set supplied out[i] = this[i]^-1.

◆ elementwiseInvert() [2/2]

template<class ELT >
VectorBase<typename CNT<ELT>::TInvert> SimTK::VectorBase< ELT >::elementwiseInvert ( ) const
inline

Return out[i]=this[i]^-1 as function return.

◆ elementwiseMultiplyInPlace()

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::elementwiseMultiplyInPlace ( const VectorBase< EE > &  r)
inline

◆ elementwiseMultiply() [1/2]

template<class ELT >
template<class EE >
void SimTK::VectorBase< ELT >::elementwiseMultiply ( const VectorBase< EE > &  v,
typename EltResult< EE >::Mul &  out 
) const
inline

◆ elementwiseMultiply() [2/2]

template<class ELT >
template<class EE >
EltResult<EE>::Mul SimTK::VectorBase< ELT >::elementwiseMultiply ( const VectorBase< EE > &  v) const
inline

◆ elementwiseMultiplyFromLeftInPlace()

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::elementwiseMultiplyFromLeftInPlace ( const VectorBase< EE > &  r)
inline

◆ elementwiseMultiplyFromLeft() [1/2]

template<class ELT >
template<class EE >
void SimTK::VectorBase< ELT >::elementwiseMultiplyFromLeft ( const VectorBase< EE > &  v,
typename VectorBase< EE >::template EltResult< ELT >::Mul &  out 
) const
inline

◆ elementwiseMultiplyFromLeft() [2/2]

template<class ELT >
template<class EE >
VectorBase<EE>::template EltResult<ELT>::Mul SimTK::VectorBase< ELT >::elementwiseMultiplyFromLeft ( const VectorBase< EE > &  v) const
inline

◆ elementwiseDivideInPlace()

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::elementwiseDivideInPlace ( const VectorBase< EE > &  r)
inline

◆ elementwiseDivide() [1/2]

template<class ELT >
template<class EE >
void SimTK::VectorBase< ELT >::elementwiseDivide ( const VectorBase< EE > &  v,
typename EltResult< EE >::Dvd &  out 
) const
inline

◆ elementwiseDivide() [2/2]

template<class ELT >
template<class EE >
EltResult<EE>::Dvd SimTK::VectorBase< ELT >::elementwiseDivide ( const VectorBase< EE > &  v) const
inline

◆ elementwiseDivideFromLeftInPlace()

template<class ELT >
template<class EE >
VectorBase& SimTK::VectorBase< ELT >::elementwiseDivideFromLeftInPlace ( const VectorBase< EE > &  r)
inline

◆ elementwiseDivideFromLeft() [1/2]

template<class ELT >
template<class EE >
void SimTK::VectorBase< ELT >::elementwiseDivideFromLeft ( const VectorBase< EE > &  v,
typename VectorBase< EE >::template EltResult< ELT >::Dvd &  out 
) const
inline

◆ elementwiseDivideFromLeft() [2/2]

template<class ELT >
template<class EE >
VectorBase<EE>::template EltResult<ELT>::Dvd SimTK::VectorBase< ELT >::elementwiseDivideFromLeft ( const VectorBase< EE > &  v) const
inline

◆ operator const Vector_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator const Vector_< ELT > & ( ) const
inline

◆ operator Vector_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator Vector_< ELT > & ( )
inline

◆ operator const VectorView_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator const VectorView_< ELT > & ( ) const
inline

◆ operator VectorView_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator VectorView_< ELT > & ( )
inline

◆ operator const Matrix_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator const Matrix_< ELT > & ( ) const
inline

◆ operator Matrix_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator Matrix_< ELT > & ( )
inline

◆ operator const MatrixView_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator const MatrixView_< ELT > & ( ) const
inline

◆ operator MatrixView_< ELT > &()

template<class ELT >
SimTK::VectorBase< ELT >::operator MatrixView_< ELT > & ( )
inline

◆ size()

template<class ELT >
int SimTK::VectorBase< ELT >::size ( ) const
inline

◆ nrow()

template<class ELT >
int SimTK::VectorBase< ELT >::nrow ( ) const
inline

◆ ncol()

template<class ELT >
int SimTK::VectorBase< ELT >::ncol ( ) const
inline

◆ nelt()

template<class ELT >
ptrdiff_t SimTK::VectorBase< ELT >::nelt ( ) const
inline

◆ abs()

template<class ELT >
TAbs SimTK::VectorBase< ELT >::abs ( ) const
inline

◆ operator[]() [1/2]

template<class ELT >
const ELT& SimTK::VectorBase< ELT >::operator[] ( int  i) const
inline

◆ operator[]() [2/2]

template<class ELT >
ELT& SimTK::VectorBase< ELT >::operator[] ( int  i)
inline

◆ operator()() [1/6]

template<class ELT >
const ELT& SimTK::VectorBase< ELT >::operator() ( int  i) const
inline

◆ operator()() [2/6]

template<class ELT >
ELT& SimTK::VectorBase< ELT >::operator() ( int  i)
inline

◆ operator()() [3/6]

template<class ELT >
VectorView_<ELT> SimTK::VectorBase< ELT >::operator() ( int  i,
int  m 
) const
inline

◆ operator()() [4/6]

template<class ELT >
VectorView_<ELT> SimTK::VectorBase< ELT >::operator() ( int  i,
int  m 
)
inline

◆ index()

template<class ELT >
VectorView_<ELT> SimTK::VectorBase< ELT >::index ( const Array_< int > &  indices) const
inline

◆ updIndex()

template<class ELT >
VectorView_<ELT> SimTK::VectorBase< ELT >::updIndex ( const Array_< int > &  indices)
inline

◆ operator()() [5/6]

template<class ELT >
VectorView_<ELT> SimTK::VectorBase< ELT >::operator() ( const Array_< int > &  indices) const
inline

◆ operator()() [6/6]

template<class ELT >
VectorView_<ELT> SimTK::VectorBase< ELT >::operator() ( const Array_< int > &  indices)
inline

◆ transpose()

template<class ELT >
THerm SimTK::VectorBase< ELT >::transpose ( ) const
inline

◆ updTranspose()

template<class ELT >
THerm SimTK::VectorBase< ELT >::updTranspose ( )
inline

◆ operator~() [1/2]

template<class ELT >
THerm SimTK::VectorBase< ELT >::operator~ ( ) const
inline

◆ operator~() [2/2]

template<class ELT >
THerm SimTK::VectorBase< ELT >::operator~ ( )
inline

◆ operator+()

template<class ELT >
const VectorBase& SimTK::VectorBase< ELT >::operator+ ( ) const
inline

◆ negate()

template<class ELT >
const TNeg& SimTK::VectorBase< ELT >::negate ( ) const
inline

◆ updNegate()

template<class ELT >
TNeg& SimTK::VectorBase< ELT >::updNegate ( )
inline

◆ operator-() [1/2]

template<class ELT >
const TNeg& SimTK::VectorBase< ELT >::operator- ( ) const
inline

◆ operator-() [2/2]

template<class ELT >
TNeg& SimTK::VectorBase< ELT >::operator- ( )
inline

◆ resize()

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::resize ( int  m)
inline

◆ resizeKeep()

template<class ELT >
VectorBase& SimTK::VectorBase< ELT >::resizeKeep ( int  m)
inline

◆ clear()

template<class ELT >
void SimTK::VectorBase< ELT >::clear ( )
inline

◆ sum()

template<class ELT >
ELT SimTK::VectorBase< ELT >::sum ( ) const
inline

◆ begin()

template<class ELT >
VectorIterator<ELT, VectorBase<ELT> > SimTK::VectorBase< ELT >::begin ( )
inline

◆ end()

template<class ELT >
VectorIterator<ELT, VectorBase<ELT> > SimTK::VectorBase< ELT >::end ( )
inline

Friends And Related Function Documentation

◆ writeUnformatted()

template<class E >
void writeUnformatted ( std::ostream &  o,
const VectorBase< E > &  v 
)
related

Specialize for VectorBase<E> to delegate to element type E, with spaces separating the elements.


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