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

#include <VectorBase.h>

Inheritance diagram for SimTK::VectorBase< ELT >:

Classes
struct	EltResult

Public Member Functions
VectorBase &	operator= (const VectorBase &b)
	Copy assignment is deep copy but behavior depends on type of lhs: if view, rhs must match.
VectorBase &	operator*= (const StdNumber &t)
VectorBase &	operator/= (const StdNumber &t)
VectorBase &	operator+= (const VectorBase &r)
VectorBase &	operator-= (const VectorBase &r)
template<class EE >
VectorBase &	operator= (const VectorBase< EE > &b)
template<class EE >
VectorBase &	operator+= (const VectorBase< EE > &b)
template<class EE >
VectorBase &	operator-= (const VectorBase< EE > &b)
VectorBase &	operator= (const ELT &t)
	Fill current allocation with copies of element.
template<class EE >
VectorBase &	rowScaleInPlace (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.
template<class EE >
void	rowScale (const VectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
	Return type is a new matrix which will have the same dimensions as 'this' but will have element types appropriate for the elementwise multiply being performed.
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.
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.
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.
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.
VectorBase &	elementwiseInvertInPlace ()
	Set this[i] = this[i]^-1.
void	elementwiseInvert (VectorBase< typename CNT< ELT >::TInvert > &out) const
	Set supplied out[i] = this[i]^-1.
VectorBase< typename CNT< ELT > ::TInvert >	elementwiseInvert () const
	Return out[i]=this[i]^-1 as function return.
template<class EE >
VectorBase &	elementwiseMultiplyInPlace (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 >
VectorBase &	elementwiseMultiplyFromLeftInPlace (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 >
VectorBase &	elementwiseDivideInPlace (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 >
VectorBase &	elementwiseDivideFromLeftInPlace (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
	Return the number of rows m in the logical shape of this matrix.
int	ncol () const
	Return the number of columns n in the logical shape of this matrix.
ptrdiff_t	nelt () const
	Return the number of elements in the logical shape of this matrix.
TAbs	abs () const
	abs() with the result as a function return.
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 VectorBase &	operator+ () const
const TNeg &	negate () const
TNeg &	updNegate ()
const TNeg &	operator- () const
TNeg &	operator- ()
VectorBase &	resize (int m)
VectorBase &	resizeKeep (int m)
void	clear ()
	This restores the MatrixBase to the state it would be in had it been constructed specifying only its handle commitment.
ELT	sum () const
	Alternate name for colSum(); behaves like the Matlab function sum().
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.
	VectorBase (const VectorBase &source)
	Copy constructor is a deep copy (not appropriate for views!).
	VectorBase (const TNeg &source)
	Implicit conversion from compatible vector with negated elements.
	VectorBase (int m, const ELT &initialValue)
	Construct an owner vector of length m, with each element initialized to the given value.
	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.
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.
	VectorBase (int m, int stride, Scalar *s)
	Construct a writable view into existing data.
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.
	VectorBase (const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
	Construct a read-only view of the source data.
	VectorBase (const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::DeepCopy &d)
	Construct a new owner vector initialized with the data from the source.
Public Member Functions inherited from SimTK::MatrixBase< ELT >
const MatrixCommitment &	getCharacterCommitment () const
const MatrixCharacter &	getMatrixCharacter () const
void	commitTo (const MatrixCommitment &mc)
	Change the handle commitment for this matrix handle; only allowed if the handle is currently clear.
bool	isResizeable () const
	Return true if either dimension of this Matrix is resizable.
	MatrixBase ()
	The default constructor builds a 0x0 matrix managed by a helper that understands how many scalars there are in one of our elements but is otherwise uncommitted.
	MatrixBase (int m, int n)
	This constructor allocates the default matrix a completely uncommitted matrix commitment, given particular initial dimensions.
	MatrixBase (const MatrixCommitment &commitment)
	This constructor takes a handle commitment and allocates the default matrix for that kind of commitment.
	MatrixBase (const MatrixCommitment &commitment, int m, int n)
	This constructor takes a handle commitment and allocates the default matrix for that kind of commitment given particular initial minimum dimensions, which cannot be larger than those permitted by the commitment.
	MatrixBase (const MatrixBase &b)
	Copy constructor is a deep copy (not appropriate for views!).
	MatrixBase (const TNeg &b)
	Implicit conversion from matrix with negated elements (otherwise this is just like the copy constructor.
MatrixBase &	copyAssign (const MatrixBase &b)
	Copy assignment is a deep copy but behavior depends on type of lhs: if view, rhs must match.
MatrixBase &	operator= (const MatrixBase &b)
MatrixBase &	viewAssign (const MatrixBase &src)
	View assignment is a shallow copy, meaning that we disconnect the MatrixBase from whatever it used to refer to (destructing as necessary), then make it a new view for the data descriptor referenced by the source.
	MatrixBase (const MatrixCommitment &commitment, int m, int n, const ELT &initialValue)
	Initializing constructor with all of the initially-allocated elements initialized to the same value.
	MatrixBase (const MatrixCommitment &commitment, int m, int n, const ELT *cppInitialValuesByRow)
	Initializing constructor with the initially-allocated elements initialized from a C++ array of elements, which is provided in row major order.
	MatrixBase (const MatrixCommitment &commitment, MatrixHelper< Scalar > &source, const typename MatrixHelper< Scalar >::ShallowCopy &shallow)
	MatrixBase (const MatrixCommitment &commitment, const MatrixHelper< Scalar > &source, const typename MatrixHelper< Scalar >::ShallowCopy &shallow)
	MatrixBase (const MatrixCommitment &commitment, const MatrixHelper< Scalar > &source, const typename MatrixHelper< Scalar >::DeepCopy &deep)
MatrixBase &	operator+= (const MatrixBase &r)
MatrixBase &	operator-= (const MatrixBase &r)
template<class EE >
	MatrixBase (const MatrixBase< EE > &b)
template<class EE >
MatrixBase &	operator= (const MatrixBase< EE > &b)
template<class EE >
MatrixBase &	operator+= (const MatrixBase< EE > &b)
template<class EE >
MatrixBase &	operator-= (const MatrixBase< EE > &b)
template<class S >
MatrixBase &	scalarAssign (const S &s)
	Set M's diagonal elements to a "scalar" value S, and all off-diagonal elements to zero.
template<class S >
MatrixBase &	scalarAddInPlace (const S &s)
	Add a scalar to M's diagonal.
template<class S >
MatrixBase &	scalarSubtractInPlace (const S &s)
	Subtract a scalar from M's diagonal.
template<class S >
MatrixBase &	scalarSubtractFromLeftInPlace (const S &s)
	Set M(i,i) = S - M(i,i), M(i,j) = -M(i,j) for i!=j.
template<class S >
MatrixBase &	scalarMultiplyInPlace (const S &)
	Set M(i,j) = M(i,j)*S for some "scalar" S.
template<class S >
MatrixBase &	scalarMultiplyFromLeftInPlace (const S &)
	Set M(i,j) = S * M(i,j) for some "scalar" S.
template<class S >
MatrixBase &	scalarDivideInPlace (const S &)
	Set M(i,j) = M(i,j)/S for some "scalar" S.
template<class S >
MatrixBase &	scalarDivideFromLeftInPlace (const S &)
	Set M(i,j) = S/M(i,j) for some "scalar" S.
template<class EE >
MatrixBase &	colScaleInPlace (const VectorBase< EE > &)
	M = M * diag(c); c must have ncol() elements.
template<class EE >
void	colScale (const VectorBase< EE > &c, typename EltResult< EE >::Mul &out) const
template<class EE >
EltResult< EE >::Mul	colScale (const VectorBase< EE > &c) const
template<class ER , class EC >
MatrixBase &	rowAndColScaleInPlace (const VectorBase< ER > &r, const VectorBase< EC > &c)
	M = diag(r) * M * diag(c); r must have nrow() elements; must have ncol() elements.
template<class ER , class EC >
void	rowAndColScale (const VectorBase< ER > &r, const VectorBase< EC > &c, typename EltResult< typename VectorBase< ER >::template EltResult< EC >::Mul >::Mul &out) const
template<class ER , class EC >
EltResult< typename VectorBase < ER >::template EltResult< EC > ::Mul >::Mul	rowAndColScale (const VectorBase< ER > &r, const VectorBase< EC > &c) const
template<class S >
MatrixBase &	elementwiseAssign (const S &s)
	Set M(i,j)=s for every element of M and some value s.
MatrixBase &	elementwiseAssign (int s)
	Overloaded to allow an integer argument, which is converted to Real.
void	elementwiseInvert (MatrixBase< typename CNT< E >::TInvert > &out) const
template<class S >
MatrixBase &	elementwiseAddScalarInPlace (const S &s)
	Set M(i,j)+=s for every element of M and some value s.
template<class S >
void	elementwiseAddScalar (const S &s, typename EltResult< S >::Add &) const
template<class S >
EltResult< S >::Add	elementwiseAddScalar (const S &s) const
template<class S >
MatrixBase &	elementwiseSubtractScalarInPlace (const S &s)
	Set M(i,j)-=s for every element of M and some value s.
template<class S >
void	elementwiseSubtractScalar (const S &s, typename EltResult< S >::Sub &) const
template<class S >
EltResult< S >::Sub	elementwiseSubtractScalar (const S &s) const
template<class S >
MatrixBase &	elementwiseSubtractFromScalarInPlace (const S &s)
	Set M(i,j) = s - M(i,j) for every element of M and some value s.
template<class S >
void	elementwiseSubtractFromScalar (const S &, typename MatrixBase< S >::template EltResult< E >::Sub &) const
template<class S >
MatrixBase< S >::template EltResult< E >::Sub	elementwiseSubtractFromScalar (const S &s) const
template<class EE >
MatrixBase &	elementwiseMultiplyInPlace (const MatrixBase< EE > &)
	M(i,j) *= R(i,j); R must have same dimensions as this.
template<class EE >
void	elementwiseMultiply (const MatrixBase< EE > &, typename EltResult< EE >::Mul &) const
template<class EE >
EltResult< EE >::Mul	elementwiseMultiply (const MatrixBase< EE > &m) const
template<class EE >
MatrixBase &	elementwiseMultiplyFromLeftInPlace (const MatrixBase< EE > &)
	M(i,j) = R(i,j) * M(i,j); R must have same dimensions as this.
template<class EE >
void	elementwiseMultiplyFromLeft (const MatrixBase< EE > &, typename MatrixBase< EE >::template EltResult< E >::Mul &) const
template<class EE >
MatrixBase< EE >::template EltResult< E >::Mul	elementwiseMultiplyFromLeft (const MatrixBase< EE > &m) const
template<class EE >
MatrixBase &	elementwiseDivideInPlace (const MatrixBase< EE > &)
	M(i,j) /= R(i,j); R must have same dimensions as this.
template<class EE >
void	elementwiseDivide (const MatrixBase< EE > &, typename EltResult< EE >::Dvd &) const
template<class EE >
EltResult< EE >::Dvd	elementwiseDivide (const MatrixBase< EE > &m) const
template<class EE >
MatrixBase &	elementwiseDivideFromLeftInPlace (const MatrixBase< EE > &)
	M(i,j) = R(i,j) / M(i,j); R must have same dimensions as this.
template<class EE >
void	elementwiseDivideFromLeft (const MatrixBase< EE > &, typename MatrixBase< EE >::template EltResult< E >::Dvd &) const
template<class EE >
MatrixBase< EE >::template EltResult< EE >::Dvd	elementwiseDivideFromLeft (const MatrixBase< EE > &m) const
MatrixBase &	setTo (const ELT &t)
	Fill every element in current allocation with given element (or NaN or 0).
MatrixBase &	setToNaN ()
MatrixBase &	setToZero ()
RowVectorView_< ELT >	row (int i) const
RowVectorView_< ELT >	updRow (int i)
VectorView_< ELT >	col (int j) const
VectorView_< ELT >	updCol (int j)
MatrixView_< ELT >	block (int i, int j, int m, int n) const
MatrixView_< ELT >	updBlock (int i, int j, int m, int n)
MatrixView_< ELT >	operator() (int i, int j, int m, int n) const
MatrixView_< ELT >	operator() (int i, int j, int m, int n)
VectorView_< ELT >	diag () const
	Select main diagonal (of largest leading square if rectangular) and return it as a read-only view of the diagonal elements of this Matrix.
VectorView_< ELT >	updDiag ()
	Select main diagonal (of largest leading square if rectangular) and return it as a writable view of the diagonal elements of this Matrix.
VectorView_< ELT >	diag ()
	This non-const version of diag() is an alternate name for updDiag() available for historical reasons.
TInvert	invert () const
void	invertInPlace ()
void	dump (const char *msg=0) const
	Matlab-compatible debug output.
template<class ELT_A , class ELT_B >
MatrixBase &	matmul (const StdNumber &beta, const StdNumber &alpha, const MatrixBase< ELT_A > &A, const MatrixBase< ELT_B > &B)
const ELT &	getElt (int i, int j) const
	Element selection for stored elements.
ELT &	updElt (int i, int j)
void	getAnyElt (int i, int j, ELT &value) const
	This returns a copy of the element value for any position in the logical matrix, regardless of whether it is stored in memory.
ELT	getAnyElt (int i, int j) const
ScalarNormSq	scalarNormSqr () const
	Scalar norm square is sum( squares of all scalars ).
void	abs (TAbs &mabs) const
	abs() is elementwise absolute value; that is, the return value has the same dimension as this Matrix but with each element replaced by whatever it thinks its absolute value is.
TStandard	standardize () const
	Return a Matrix of the same shape and contents as this one but with the element type converted to one based on the standard C++ scalar types: float, double, complex<float>, complex<double>.
ScalarNormSq	normSqr () const
	This is the scalar Frobenius norm, and its square.
CNT< ScalarNormSq >::TSqrt	norm () const
CNT< ScalarNormSq >::TSqrt	normRMS () const
	We only allow RMS norm if the elements are scalars.
RowVector_< ELT >	colSum () const
	Form the column sums of this matrix, returned as a RowVector.
Vector_< ELT >	rowSum () const
	Form the row sums of this matrix, returned as a Vector.
MatrixBase &	negateInPlace ()
MatrixBase &	resize (int m, int n)
	Change the size of this matrix.
MatrixBase &	resizeKeep (int m, int n)
	Change the size of this matrix, retaining as much of the old data as will fit.
void	lockShape ()
void	unlockShape ()
const MatrixView_< ELT > &	getAsMatrixView () const
MatrixView_< ELT > &	updAsMatrixView ()
const Matrix_< ELT > &	getAsMatrix () const
Matrix_< ELT > &	updAsMatrix ()
const VectorView_< ELT > &	getAsVectorView () const
VectorView_< ELT > &	updAsVectorView ()
const Vector_< ELT > &	getAsVector () const
Vector_< ELT > &	updAsVector ()
const VectorBase< ELT > &	getAsVectorBase () const
VectorBase< ELT > &	updAsVectorBase ()
const RowVectorView_< ELT > &	getAsRowVectorView () const
RowVectorView_< ELT > &	updAsRowVectorView ()
const RowVector_< ELT > &	getAsRowVector () const
RowVector_< ELT > &	updAsRowVector ()
const RowVectorBase< ELT > &	getAsRowVectorBase () const
RowVectorBase< ELT > &	updAsRowVectorBase ()
int	getNScalarsPerElement () const
	This is the number of consecutive scalars used to represent one element of type ELT.
int	getPackedSizeofElement () const
	This is like sizeof(ELT), but returning the number of bytes we use to store the element which may be fewer than what C++ would use.
bool	hasContiguousData () const
ptrdiff_t	getContiguousScalarDataLength () const
const Scalar *	getContiguousScalarData () const
Scalar *	updContiguousScalarData ()
void	replaceContiguousScalarData (Scalar *newData, ptrdiff_t length, bool takeOwnership)
void	replaceContiguousScalarData (const Scalar *newData, ptrdiff_t length)
void	swapOwnedContiguousScalarData (Scalar newData, ptrdiff_t length, Scalar &oldData)
	MatrixBase (MatrixHelperRep< Scalar > *hrep)
	Helper rep-stealing constructor.
template<class EE >
void	rowScale (const VectorBase< EE > &v, typename MatrixBase< ELT >::template EltResult< EE >::Mul &out) const
template<class EE >
void	colScale (const VectorBase< EE > &v, typename MatrixBase< ELT >::template EltResult< EE >::Mul &out) const
template<class S >
void	elementwiseAddScalar (const S &s, typename MatrixBase< ELT >::template EltResult< S >::Add &out) const
template<class S >
void	elementwiseSubtractScalar (const S &s, typename MatrixBase< ELT >::template EltResult< S >::Sub &out) const
template<class EE >
void	elementwiseMultiply (const MatrixBase< EE > &r, typename MatrixBase< ELT >::template EltResult< EE >::Mul &out) const
template<class EE >
void	elementwiseDivide (const MatrixBase< EE > &r, typename MatrixBase< ELT >::template EltResult< EE >::Dvd &out) const
	MatrixBase (const MatrixCommitment &commitment, const MatrixCharacter &character, int spacing, const Scalar *data)
	Construct a read-only view of pre-existing data.
	MatrixBase (const MatrixCommitment &commitment, const MatrixCharacter &character, int spacing, Scalar *data)
	Construct a writable view of pre-existing data.

Protected Member Functions
	VectorBase (MatrixHelperRep< Scalar > *hrep)
Protected Member Functions inherited from SimTK::MatrixBase< ELT >
const MatrixHelper< Scalar > &	getHelper () const
MatrixHelper< Scalar > &	updHelper ()

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.
Related Functions inherited from SimTK::MatrixBase< ELT >
template<class E >
void	writeUnformatted (std::ostream &o, const MatrixBase< E > &v)
	Specialize for MatrixBase<E> delegating to RowVectorBase<E> with newlines separating the rows, but no final newline.

Additional Inherited Members
Public Types inherited from SimTK::MatrixBase< ELT >
enum	{ NScalarsPerElement = CNT<E>::NActualScalars, CppNScalarsPerElement = sizeof(E) / sizeof(Scalar) }
typedef ELT	E
typedef CNT< E >::TNeg	ENeg
typedef CNT< E >::TWithoutNegator	EWithoutNegator
typedef CNT< E >::TReal	EReal
typedef CNT< E >::TImag	EImag
typedef CNT< E >::TComplex	EComplex
typedef CNT< E >::THerm	EHerm
typedef CNT< E >::TPosTrans	EPosTrans
typedef CNT< E >::TAbs	EAbs
typedef CNT< E >::TStandard	EStandard
typedef CNT< E >::TInvert	EInvert
typedef CNT< E >::TNormalize	ENormalize
typedef CNT< E >::TSqHermT	ESqHermT
typedef CNT< E >::TSqTHerm	ESqTHerm
typedef CNT< E >::Scalar	EScalar
typedef CNT< E >::Number	ENumber
typedef CNT< E >::StdNumber	EStdNumber
typedef CNT< E >::Precision	EPrecision
typedef CNT< E >::ScalarNormSq	EScalarNormSq
typedef EScalar	Scalar
typedef ENumber	Number
typedef EStdNumber	StdNumber
typedef EPrecision	Precision
typedef EScalarNormSq	ScalarNormSq
typedef MatrixBase< E >	T
typedef MatrixBase< ENeg >	TNeg
typedef MatrixBase < EWithoutNegator >	TWithoutNegator
typedef MatrixBase< EReal >	TReal
typedef MatrixBase< EImag >	TImag
typedef MatrixBase< EComplex >	TComplex
typedef MatrixBase< EHerm >	THerm
typedef MatrixBase< E >	TPosTrans
typedef MatrixBase< EAbs >	TAbs
typedef MatrixBase< EStandard >	TStandard
typedef MatrixBase< EInvert >	TInvert
typedef MatrixBase< ENormalize >	TNormalize
typedef MatrixBase< ESqHermT >	TSqHermT
typedef MatrixBase< ESqTHerm >	TSqTHerm

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

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.

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.

template<class ELT>

SimTK::VectorBase< ELT >::VectorBase ( const TNeg & source )

inline

Implicit conversion from compatible vector with negated elements.

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.

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++.

template<class ELT>

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

inline

Construct a read-only view of existing data.

template<class ELT>

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

inline

Construct a writable view into existing data.

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.

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.

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.

template<class ELT>

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

inlineexplicitprotected

Member Function Documentation

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.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

Reimplemented in SimTK::Vector_< ELT >, SimTK::Vector_< T >, SimTK::Vector_< Real >, and SimTK::VectorView_< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

Reimplemented in SimTK::Vector_< ELT >, SimTK::Vector_< T >, SimTK::Vector_< Real >, and SimTK::VectorView_< ELT >.

template<class ELT>

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

inline

template<class ELT>

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

inline

template<class ELT>

template<class EE >

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

inline

Reimplemented in SimTK::Vector_< ELT >, SimTK::Vector_< T >, SimTK::Vector_< Real >, and SimTK::VectorView_< ELT >.

template<class ELT>

template<class EE >

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

inline

Reimplemented in SimTK::Vector_< ELT >, SimTK::Vector_< T >, SimTK::Vector_< Real >, and SimTK::VectorView_< ELT >.

template<class ELT>

template<class EE >

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

inline

Reimplemented in SimTK::Vector_< ELT >, SimTK::Vector_< T >, SimTK::Vector_< Real >, and SimTK::VectorView_< ELT >.

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.)

Reimplemented from SimTK::MatrixBase< ELT >.

Reimplemented in SimTK::Vector_< ELT >, SimTK::Vector_< T >, SimTK::Vector_< Real >, and SimTK::VectorView_< ELT >.

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.

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

template<class EE >

void SimTK::VectorBase< ELT >::rowScale	(	const VectorBase< EE > &	r,
		typename EltResult< EE >::Mul &	out
	)		const

inline

Return type is a new matrix which will have the same dimensions as 'this' but will have element types appropriate for the elementwise multiply being performed.

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

template<class EE >

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

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.

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.

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.

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.

template<class ELT>

VectorBase& SimTK::VectorBase< ELT >::elementwiseInvertInPlace ( )

inline

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

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

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

template<class ELT>

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

inline

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

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

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

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

template<class ELT>

template<class EE >

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

inline

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

template<class ELT>

template<class EE >

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

inline

template<class ELT>

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

inline

template<class ELT>

SimTK::VectorBase< ELT >::operator Vector_< ELT > & ( )

inline

template<class ELT>

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

inline

template<class ELT>

SimTK::VectorBase< ELT >::operator VectorView_< ELT > & ( )

inline

template<class ELT>

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

inline

template<class ELT>

SimTK::VectorBase< ELT >::operator Matrix_< ELT > & ( )

inline

template<class ELT>

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

inline

template<class ELT>

SimTK::VectorBase< ELT >::operator MatrixView_< ELT > & ( )

inline

template<class ELT>

int SimTK::VectorBase< ELT >::size ( ) const

inline

template<class ELT>

int SimTK::VectorBase< ELT >::nrow ( ) const

inline

Return the number of rows m in the logical shape of this matrix.

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

int SimTK::VectorBase< ELT >::ncol ( ) const

inline

Return the number of columns n in the logical shape of this matrix.

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

ptrdiff_t SimTK::VectorBase< ELT >::nelt ( ) const

inline

Return the number of elements in the logical shape of this matrix.

This has nothing to do with how many elements are actually stored; it is simply the product of the logical number of rows and columns, that is, nrow()*ncol(). Note that although each dimension is limited to a 32 bit size, the product of those dimensions may be > 32 bits on a 64 bit machine so the return type may be larger than that of nrow() and ncol().

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

TAbs SimTK::VectorBase< ELT >::abs ( ) const

inline

abs() with the result as a function return.

More convenient than the other abs() member function, but may involve an additional copy of the matrix.

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

template<class ELT>

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

inline

template<class ELT>

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

inline

template<class ELT>

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

inline

template<class ELT>

THerm SimTK::VectorBase< ELT >::transpose ( ) const

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

THerm SimTK::VectorBase< ELT >::updTranspose ( )

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

THerm SimTK::VectorBase< ELT >::operator~ ( )

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

TNeg& SimTK::VectorBase< ELT >::updNegate ( )

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

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

inline

template<class ELT>

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

inline

template<class ELT>

void SimTK::VectorBase< ELT >::clear ( )

inline

This restores the MatrixBase to the state it would be in had it been constructed specifying only its handle commitment.

The size will have been reduced to the smallest size consistent with the commitment.

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

ELT SimTK::VectorBase< ELT >::sum ( ) const

inline

Alternate name for colSum(); behaves like the Matlab function sum().

Reimplemented from SimTK::MatrixBase< ELT >.

template<class ELT>

VectorIterator<ELT, VectorBase<ELT> > SimTK::VectorBase< ELT >::begin ( )

inline

template<class ELT>

VectorIterator<ELT, VectorBase<ELT> > SimTK::VectorBase< ELT >::end ( )

inline

Friends And Related Function Documentation

template<class E >

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

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

Classes

Public Member Functions

Protected Member Functions

Related Functions

Additional Inherited Members

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

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