1#ifndef SimTK_SIMMATRIX_BIGMATRIX_H_
2#define SimTK_SIMMATRIX_BIGMATRIX_H_
163 template <
class ELT>
class MatrixBase;
164 template <
class ELT>
class VectorBase;
165 template <
class ELT>
class RowVectorBase;
167 template <
class ELT = Real>
class MatrixView_;
168 template <
class ELT = Real>
class Matrix_;
170 template <
class ELT = Real>
class VectorView_;
171 template <
class ELT = Real>
class Vector_;
173 template <
class ELT = Real>
class RowVectorView_;
174 template <
class ELT = Real>
class RowVector_;
176 template <
class ELT,
class VECTOR_CLASS>
class VectorIterator;
199template <
class ELT>
inline MatrixView_<ELT>
256 helper,0,j,nrow(),1);
265 helper,0,j,nrow(),1);
274 helper,i,0,1,ncol());
283 helper,i,0,1,ncol());
291 assert(v.
nrow() == nrow());
292 for (
int i=0; i < nrow(); ++i)
297template <
class ELT>
template <
class EE>
inline void
299 assert(v.
nrow() == nrow());
300 out.
resize(nrow(), ncol());
301 for (
int j=0; j<ncol(); ++j)
302 for (
int i=0; i<nrow(); ++i)
303 out(i,j) = (*this)(i,j) * v[i];
310 assert(v.
nrow() == ncol());
311 for (
int j=0; j < ncol(); ++j)
316template <
class ELT>
template <
class EE>
inline void
318 assert(v.
nrow() == ncol());
319 out.
resize(nrow(), ncol());
320 for (
int j=0; j<ncol(); ++j)
321 for (
int i=0; i<nrow(); ++i)
322 out(i,j) = (*this)(i,j) * v[j];
327template <
class ELT>
template <
class ER,
class EC>
inline MatrixBase<ELT>&
329 assert(r.
nrow()==nrow() && c.
nrow()==ncol());
330 for (
int j=0; j<ncol(); ++j)
331 for (
int i=0; i<nrow(); ++i)
332 (*
this)(i,j) *= (r[i]*c[j]);
336template <
class ELT>
template <
class ER,
class EC>
inline void
343 assert(r.
nrow()==nrow() && c.
nrow()==ncol());
344 out.resize(nrow(), ncol());
345 for (
int j=0; j<ncol(); ++j)
346 for (
int i=0; i<nrow(); ++i)
347 out(i,j) = (*this)(i,j) * (r[i]*c[j]);
353 for (
int j=0; j<ncol(); ++j)
354 for (
int i=0; i<nrow(); ++i)
362 const int nr=nrow(), nc=ncol();
363 for (
int j=0; j<nc; ++j)
364 for (
int i=0; i<nr; ++i) {
365 ELT& e = updElt(i,j);
371template <
class ELT>
inline void
373 const int nr=nrow(), nc=ncol();
375 for (
int j=0; j<nc; ++j)
376 for (
int i=0; i<nr; ++i)
383 for (
int j=0; j<ncol(); ++j)
384 for (
int i=0; i<nrow(); ++i)
389template <
class ELT>
template <
class S>
inline void
394 const int nr=nrow(), nc=ncol();
396 for (
int j=0; j<nc; ++j)
397 for (
int i=0; i<nr; ++i)
398 out(i,j) = (*this)(i,j) + s;
404 for (
int j=0; j<ncol(); ++j)
405 for (
int i=0; i<nrow(); ++i)
410template <
class ELT>
template <
class S>
inline void
415 const int nr=nrow(), nc=ncol();
417 for (
int j=0; j<nc; ++j)
418 for (
int i=0; i<nr; ++i)
419 out(i,j) = (*this)(i,j) - s;
425 const int nr=nrow(), nc=ncol();
426 for (
int j=0; j<nc; ++j)
427 for (
int i=0; i<nr; ++i) {
428 ELT& e = updElt(i,j);
434template <
class ELT>
template <
class S>
inline void
439 const int nr=nrow(), nc=ncol();
441 for (
int j=0; j<nc; ++j)
442 for (
int i=0; i<nr; ++i)
443 out(i,j) = s - (*this)(i,j);
449 const int nr=nrow(), nc=ncol();
451 for (
int j=0; j<nc; ++j)
452 for (
int i=0; i<nr; ++i)
453 (*
this)(i,j) *= r(i,j);
457template <
class ELT>
template <
class EE>
inline void
462 const int nr=nrow(), nc=ncol();
463 assert(r.
nrow()==nr && r.
ncol()==nc);
465 for (
int j=0; j<nc; ++j)
466 for (
int i=0; i<nr; ++i)
467 out(i,j) = (*this)(i,j) * r(i,j);
473 const int nr=nrow(), nc=ncol();
474 assert(r.
nrow()==nr && r.
ncol()==nc);
475 for (
int j=0; j<nc; ++j)
476 for (
int i=0; i<nr; ++i) {
477 ELT& e = updElt(i,j);
483template <
class ELT>
template <
class EE>
inline void
488 const int nr=nrow(), nc=ncol();
489 assert(r.
nrow()==nr && r.
ncol()==nc);
491 for (
int j=0; j<nc; ++j)
492 for (
int i=0; i<nr; ++i)
493 out(i,j) = r(i,j) * (*this)(i,j);
499 const int nr=nrow(), nc=ncol();
500 assert(r.
nrow()==nr && r.
ncol()==nc);
501 for (
int j=0; j<nc; ++j)
502 for (
int i=0; i<nr; ++i)
503 (*
this)(i,j) /= r(i,j);
507template <
class ELT>
template <
class EE>
inline void
512 const int nr=nrow(), nc=ncol();
513 assert(r.
nrow()==nr && r.
ncol()==nc);
515 for (
int j=0; j<nc; ++j)
516 for (
int i=0; i<nr; ++i)
517 out(i,j) = (*this)(i,j) / r(i,j);
522 const int nr=nrow(), nc=ncol();
523 assert(r.
nrow()==nr && r.
ncol()==nc);
524 for (
int j=0; j<nc; ++j)
525 for (
int i=0; i<nr; ++i) {
526 ELT& e = updElt(i,j);
532template <
class ELT>
template <
class EE>
inline void
537 const int nr=nrow(), nc=ncol();
538 assert(r.
nrow()==nr && r.
ncol()==nc);
540 for (
int j=0; j<nc; ++j)
541 for (
int i=0; i<nr; ++i)
542 out(i,j) = r(i,j) / (*this)(i,j);
566template <
class E1,
class E2>
582template <
class E1,
class E2>
583Matrix_<typename CNT<E1>::template Result<E2>::Sub>
612template <
class E> Matrix_<E>
625template <
class E> Matrix_<E>
635template <
class E1,
class E2>
636Vector_<typename CNT<E1>::template Result<E2>::Add>
648template <
class E1,
class E2>
649Vector_<typename CNT<E1>::template Result<E2>::Sub>
666template <
class E> Vector_<E>
670template <
class E> Vector_<E>
674template <
class E> Vector_<E>
679template <
class E> Vector_<E>
683template <
class E> Vector_<E>
687template <
class E> Vector_<E>
695template <
class E1,
int M,
class E2,
int S>
696Vector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul>
699 for (
int i=0; i < v.
nrow(); ++i)
705template <
class E1,
int M,
class E2,
int S>
706Vector_<typename Vec<M,E2,S>::template Result<E1>::Mul>
709 for (
int i=0; i < v.
nrow(); ++i)
715template <
class E1,
int N,
class E2,
int S>
716Vector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul>
719 for (
int i=0; i < v.
nrow(); ++i)
725template <
class E1,
int N,
class E2,
int S>
726Vector_<typename Row<N,E2,S>::template Result<E1>::Mul>
729 for (
int i=0; i < v.
nrow(); ++i)
735template <
class E1,
int M,
int N,
class E2,
int S1,
int S2>
736Vector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul>
739 for (
int i=0; i < v.
nrow(); ++i)
745template <
class E1,
int M,
int N,
class E2,
int S1,
int S2>
746Vector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul>
749 for (
int i=0; i < v.
nrow(); ++i)
755template <
class E1,
int M,
class E2,
int S>
756Vector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul>
759 for (
int i=0; i < v.
nrow(); ++i)
765template <
class E1,
int M,
class E2,
int S>
766Vector_<typename SymMat<M,E2,S>::template Result<E1>::Mul>
769 for (
int i=0; i < v.
nrow(); ++i)
780template <
class E1,
class E2>
781RowVector_<typename CNT<E1>::template Result<E2>::Add>
793template <
class E1,
class E2>
794RowVector_<typename CNT<E1>::template Result<E2>::Sub>
811template <
class E> RowVector_<E>
815template <
class E> RowVector_<E>
819template <
class E> RowVector_<E>
824template <
class E> RowVector_<E>
828template <
class E> RowVector_<E>
832template <
class E> RowVector_<E>
841template <
class E1,
int M,
class E2,
int S>
842RowVector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul>
845 for (
int i=0; i < v.
ncol(); ++i)
851template <
class E1,
int M,
class E2,
int S>
852RowVector_<typename Vec<M,E2,S>::template Result<E1>::Mul>
855 for (
int i=0; i < v.
ncol(); ++i)
861template <
class E1,
int N,
class E2,
int S>
862RowVector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul>
865 for (
int i=0; i < v.
ncol(); ++i)
871template <
class E1,
int N,
class E2,
int S>
872RowVector_<typename Row<N,E2,S>::template Result<E1>::Mul>
875 for (
int i=0; i < v.
ncol(); ++i)
881template <
class E1,
int M,
int N,
class E2,
int S1,
int S2>
882RowVector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul>
885 for (
int i=0; i < v.
ncol(); ++i)
891template <
class E1,
int M,
int N,
class E2,
int S1,
int S2>
892RowVector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul>
895 for (
int i=0; i < v.
ncol(); ++i)
901template <
class E1,
int M,
class E2,
int S>
902RowVector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul>
905 for (
int i=0; i < v.
ncol(); ++i)
911template <
class E1,
int M,
class E2,
int S>
912RowVector_<typename SymMat<M,E2,S>::template Result<E1>::Mul>
915 for (
int i=0; i < v.
ncol(); ++i)
931template <
class E1,
class E2>
932typename CNT<E1>::template Result<E2>::Mul
936 for (
int j=0; j < r.
ncol(); ++j)
941template <
class E1,
class E2>
942Vector_<typename CNT<E1>::template Result<E2>::Mul>
946 for (
int i=0; i< m.
nrow(); ++i)
951template <
class E1,
class E2>
952Matrix_<typename CNT<E1>::template Result<E2>::Mul>
958 for (
int j=0; j < res.
ncol(); ++j)
959 for (
int i=0; i < res.
nrow(); ++i)
960 res(i,j) = m1[i] * m2(j);
976template <
class T>
static inline
978 (std::istream& in,
bool isFixedSize,
Vector_<T>& out)
982 if (!in.good()) {in.setstate(std::ios::failbit);
return in;}
991 const int numRequired = isFixedSize ? out.
size() : 0;
999 std::ws(in);
if (in.fail())
return in;
1001 if (isFixedSize && numRequired != 0)
1002 in.setstate(std::ios_base::failbit);
1010 typename std::iostream::int_type ch;
1012 const typename std::iostream::int_type EOFch =
1013 std::iostream::traits_type::eof();
1018 bool tildeFound =
false;
1019 ch = in.peek();
if (in.fail())
return in;
1020 assert(ch != EOFch);
1021 if ((
char)ch ==
'~') {
1025 if (in.good()) std::ws(in);
1027 if (!in.good()) {in.setstate(std::ios_base::failbit);
return in;}
1035 bool lookForCloser =
true;
1036 char openBracket, closeBracket;
1037 ch = in.peek();
if (in.fail())
return in;
1038 assert(ch != EOFch);
1040 openBracket = (char)ch;
1041 if (openBracket==
'(') {in.get(); closeBracket =
')';}
1042 else if (openBracket==
'[') {in.get(); closeBracket =
']';}
1043 else lookForCloser =
false;
1047 if (tildeFound && !lookForCloser)
1048 { in.setstate(std::ios_base::failbit);
return in;}
1054 if (in.good()) std::ws(in);
1060 assert(lookForCloser);
1061 in.setstate(std::ios::failbit);
1071 bool commaOK =
true, commaRequired =
false;
1072 bool terminatorSeen =
false;
1089 if (lookForCloser) {
1091 std::ws(in);
if (!in.good())
break;
1092 ch = in.peek(); assert(ch != EOFch);
1093 if (!in.good())
break;
1095 if (c == closeBracket) {
1097 terminatorSeen =
true;
1107 if (isFixedSize && (nextIndex == numRequired))
1111 if (commaOK && nextIndex != 0) {
1113 std::ws(in);
if (!in.good())
break;
1114 ch = in.peek(); assert(ch != EOFch);
1115 if (!in.good())
break;
1119 commaRequired =
true;
1122 { in.setstate(std::ios::failbit);
break; }
1123 else commaOK =
false;
1125 if (!in.good())
break;
1136 in >> out[nextIndex];
if (in.fail())
break;
1139 if (!in.good())
break;
1153 if (lookForCloser && !terminatorSeen)
1154 in.setstate(std::ios::failbit);
1156 if (isFixedSize && nextIndex != numRequired)
1157 in.setstate(std::ios::failbit);
1182template <
class E>
inline void
1184 const int sz = v.
size();
1185 for (
int i=0; i < sz; ++i) {
1186 if (i != 0) o <<
" ";
1192template <
class E>
inline void
1198template <
class E>
inline void
1205template <
class E>
inline void
1211template <
class E>
inline void
1217template <
class E>
inline void
1224template <
class E>
inline void
1226 const int nr = v.
nrow();
1227 for (
int i=0; i < nr; ++i) {
1228 if (i != 0) o << std::endl;
1234template <
class E>
inline void
1240template <
class E>
inline void
1247template <
class E>
inline bool
1249 for (
int i=0; i < v.
size(); ++i)
1256template <
class E>
inline bool
1264 for (
int i=0; i<a.
size(); ++i)
1272template <
class E>
inline bool
1275 return readUnformatted<E>(in, vt); }
1280template <
class E>
inline bool
1283 return readUnformatted<E>(in, vt); }
1290template <
class E>
inline bool
1292 for (
int row=0; row < v.
nrow(); ++row) {
1294 if (!readUnformatted<E>(in, oneRow))
return false;
1304template <
class E>
inline bool
1312template <
class E>
inline bool
1315 "SimTK::readUnformatted(istream, Matrix) is not implemented; try"
1316 " SimTK::fillUnformatted(istream, Matrix) instead.");
1326template <
class T>
inline std::ostream&
1331 for (
int i=1; i < v.size(); ++i) o <<
" " << v[i];
1342template <
class T>
inline std::ostream&
1347 for (
int i=1; i < v.size(); ++i) o <<
" " << v[i];
1359template <
class T>
inline std::ostream&
1361 for (
int i=0;i<m.
nrow();++i)
1362 o << std::endl << m[i];
1363 if (m.
nrow()) o << std::endl;
1399template <
class T>
static inline
1401{
return readVectorFromStreamHelper<T>(in,
false , out); }
1429template <
class T>
static inline
1431{
return readVectorFromStreamHelper<T>(in,
true , out); }
1437template <
class T>
static inline
1439{
return readVectorFromStreamHelper<T>(in,
true , out); }
1451template <
class T>
inline
1453{
return readVectorFromStream<T>(in, out); }
1462template <
class T>
inline
1464{
return fillVectorViewFromStream<T>(in, out); }
#define SimTK_INDEXCHECK(ix, ub, where)
Definition: ExceptionMacros.h:145
#define SimTK_ASSERT_ALWAYS(cond, msg)
Definition: ExceptionMacros.h:349
#define SimTK_SIZECHECK(sz, maxsz, where)
Definition: ExceptionMacros.h:146
Define the SimTK::MatrixBase class that is part of Simbody's BigMatrix toolset.
Here we declare the classes needed for managing the properties of matrices, which we call Matrix Char...
Here we declare the detailed interface to the Simmatrix classes.
Define the SimTK::MatrixView_ class that is part of Simbody's BigMatrix toolset.
Define the SimTK::Matrix_ class that is part of Simbody's BigMatrix toolset.
Define the SimTK::RowVectorBase class that is part of Simbody's BigMatrix toolset.
Define the SimTK::RowVectorView_ class that is part of Simbody's BigMatrix toolset.
Define the SimTK::RowVector_ class that is part of Simbody's BigMatrix toolset.
This is a user-includable header which includes everything needed to make use of SimMatrix Scalar cod...
This file is the user-includeable header to be included in user programs to provide fixed-length Vec ...
Define the SimTK::VectorBase class that is part of Simbody's BigMatrix toolset.
Defines an iterator that can be used to iterate over the elements of any kind of Simbody vector.
Define the SimTK::VectorView_ class that is part of Simbody's BigMatrix toolset.
Define the SimTK::Vector_ class that is part of Simbody's BigMatrix toolset.
The Array_<T> container class is a plug-compatible replacement for the C++ standard template library ...
Definition: Array.h:1520
size_type size() const
Return the current number of elements stored in this array.
Definition: Array.h:2075
Specialized information about Composite Numerical Types which allows us to define appropriate templat...
Definition: CompositeNumericalTypes.h:136
K::StdNumber StdNumber
Definition: CompositeNumericalTypes.h:163
K T
Definition: CompositeNumericalTypes.h:138
K::TInvert TInvert
Definition: CompositeNumericalTypes.h:157
static TInvert invert(const K &t)
Definition: CompositeNumericalTypes.h:243
K::THerm THerm
Definition: CompositeNumericalTypes.h:144
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition: Mat.h:97
This is the common base class for Simbody's Vector_ and Matrix_ classes for handling large,...
Definition: MatrixBase.h:68
void elementwiseDivideFromLeft(const MatrixBase< EE > &, typename MatrixBase< EE >::template EltResult< E >::Dvd &) const
Definition: BigMatrix.h:533
MatrixBase & elementwiseSubtractFromScalarInPlace(const S &s)
Set M(i,j) = s - M(i,j) for every element of M and some value s.
MatrixBase & elementwiseAssign(const S &s)
Set M(i,j)=s for every element of M and some value s.
MatrixBase & elementwiseSubtractScalarInPlace(const S &s)
Set M(i,j)-=s for every element of M and some value s.
MatrixBase & elementwiseDivideInPlace(const MatrixBase< EE > &)
M(i,j) /= R(i,j); R must have same dimensions as this.
MatrixBase & rowScaleInPlace(const VectorBase< EE > &)
M = diag(r) * M; r must have nrow() elements.
MatrixBase & elementwiseInvertInPlace()
Set M(i,j) = M(i,j)^-1.
Definition: BigMatrix.h:361
MatrixBase & elementwiseMultiplyFromLeftInPlace(const MatrixBase< EE > &)
M(i,j) = R(i,j) * M(i,j); R must have same dimensions as this.
MatrixBase & colScaleInPlace(const VectorBase< EE > &)
M = M * diag(c); c must have ncol() elements.
MatrixBase< typename CNT< E >::TInvert > elementwiseInvert() const
Definition: MatrixBase.h:452
MatrixView_< ELT > updBlock(int i, int j, int m, int n)
Definition: BigMatrix.h:211
VectorView_< ELT > updCol(int j)
Definition: BigMatrix.h:261
MatrixBase & resize(int m, int n)
Change the size of this matrix.
Definition: MatrixBase.h:773
void writeUnformatted(std::ostream &o, const MatrixBase< E > &v)
Specialize for MatrixBase<E> delegating to RowVectorBase<E> with newlines separating the rows,...
Definition: BigMatrix.h:1225
MatrixBase & elementwiseMultiplyInPlace(const MatrixBase< EE > &)
M(i,j) *= R(i,j); R must have same dimensions as this.
MatrixBase & elementwiseAddScalarInPlace(const S &s)
Set M(i,j)+=s for every element of M and some value s.
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.
MatrixView_< EHerm > updTranspose()
Definition: BigMatrix.h:230
void colScale(const VectorBase< EE > &c, typename EltResult< EE >::Mul &out) const
VectorView_< ELT > & updAsVectorView()
Definition: MatrixBase.h:799
int nrow() const
Return the number of rows m in the logical shape of this matrix.
Definition: MatrixBase.h:136
void elementwiseSubtractScalar(const S &s, typename EltResult< S >::Sub &) const
void rowAndColScale(const VectorBase< ER > &r, const VectorBase< EC > &c, typename EltResult< typename VectorBase< ER >::template EltResult< EC >::Mul >::Mul &out) const
Definition: BigMatrix.h:337
bool isResizeable() const
Return true if either dimension of this Matrix is resizable.
Definition: MatrixBase.h:150
int ncol() const
Return the number of columns n in the logical shape of this matrix.
Definition: MatrixBase.h:138
MatrixView_< ELT > block(int i, int j, int m, int n) const
Definition: BigMatrix.h:200
void elementwiseDivide(const MatrixBase< EE > &, typename EltResult< EE >::Dvd &) const
MatrixView_< ELT > & updAsMatrixView()
Definition: MatrixBase.h:793
void elementwiseSubtractFromScalar(const S &, typename MatrixBase< S >::template EltResult< E >::Sub &) const
Definition: BigMatrix.h:435
VectorView_< ELT > diag() const
Select main diagonal (of largest leading square if rectangular) and return it as a read-only view of ...
Definition: BigMatrix.h:238
void elementwiseAddScalar(const S &s, typename EltResult< S >::Add &) const
VectorView_< ELT > updDiag()
Select main diagonal (of largest leading square if rectangular) and return it as a writable view of t...
Definition: BigMatrix.h:245
void rowScale(const VectorBase< EE > &r, 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...
MatrixBase & elementwiseDivideFromLeftInPlace(const MatrixBase< EE > &)
M(i,j) = R(i,j) / M(i,j); R must have same dimensions as this.
void elementwiseMultiply(const MatrixBase< EE > &, typename EltResult< EE >::Mul &) const
VectorView_< ELT > col(int j) const
Definition: BigMatrix.h:252
RowVectorView_< ELT > updRow(int i)
Definition: BigMatrix.h:279
void elementwiseMultiplyFromLeft(const MatrixBase< EE > &, typename MatrixBase< EE >::template EltResult< E >::Mul &) const
Definition: BigMatrix.h:484
RowVectorView_< ELT > row(int i) const
Definition: BigMatrix.h:270
MatrixView_< EHerm > transpose() const
Definition: BigMatrix.h:222
This is the default commitment for a row vector.
Definition: MatrixCharacteristics.h:1005
This is the default commitment for a column vector.
Definition: MatrixCharacteristics.h:981
A MatrixCommitment provides a set of acceptable matrix characteristics.
Definition: MatrixCharacteristics.h:832
MatrixHelperRep< S > * stealRep()
Definition: MatrixHelper.h:336
(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignm...
Definition: MatrixView_.h:43
void writeUnformatted(std::ostream &o, const MatrixView_< E > &v)
Raw serialization of MatrixView_<E>; same as MatrixBase<E>.
Definition: BigMatrix.h:1235
bool readUnformatted(std::istream &in, MatrixView_< E > &v)
Read fixed-size MatrixView in row order from unformatted (whitespace- separated) input stream.
Definition: BigMatrix.h:1291
This is the matrix class intended to appear in user code for large, variable size matrices.
Definition: Matrix_.h:51
bool readUnformatted(std::istream &in, Matrix_< E > &v)
NOT IMPLEMENTED: read variable-size Matrix recognizing newlines as end of row; use fillUnformatted() ...
Definition: BigMatrix.h:1313
void writeUnformatted(std::ostream &o, const Matrix_< E > &v)
Raw serialization of Vector_<E>; same as VectorBase<E>.
Definition: BigMatrix.h:1241
bool fillUnformatted(std::istream &in, Matrix_< E > &v)
Read in new values for a Matrix without changing its size, from a stream of whitespace-separated toke...
Definition: BigMatrix.h:1305
This is a dataless rehash of the MatrixBase class to specialize it for RowVectors.
Definition: RowVectorBase.h:42
void writeUnformatted(std::ostream &o, const RowVectorBase< E > &v)
Specialize for RowVectorBase<E> to delegate to element type E, with spaces separating the elements; r...
Definition: BigMatrix.h:1206
int size() const
Definition: RowVectorBase.h:237
int ncol() const
Definition: RowVectorBase.h:243
(Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assi...
Definition: RowVectorView_.h:42
bool readUnformatted(std::istream &in, RowVectorView_< E > &v)
Read fixed-size RowVectorView from input stream.
Definition: BigMatrix.h:1273
void writeUnformatted(std::ostream &o, const RowVectorView_< E > &v)
Raw serialization of RowVectorView_<E>; same as VectorView_<E>.
Definition: BigMatrix.h:1212
Represents a variable size row vector; much less common than the column vector type Vector_.
Definition: RowVector_.h:52
void writeUnformatted(std::ostream &o, const RowVector_< E > &v)
Raw serialization of RowVector_<E>; same as Vector_<E>.
Definition: BigMatrix.h:1218
bool readUnformatted(std::istream &in, RowVector_< E > &v)
Read variable-size RowVector from unformatted (whitespace-separated) input stream.
Definition: BigMatrix.h:1281
This is a fixed-length row vector designed for no-overhead inline computation.
Definition: Row.h:132
This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation...
Definition: SymMat.h:87
This is a fixed-length column vector designed for no-overhead inline computation.
Definition: Vec.h:184
This is a dataless rehash of the MatrixBase class to specialize it for Vectors.
Definition: VectorBase.h:42
int size() const
Definition: VectorBase.h:396
void clear()
Definition: VectorBase.h:455
void writeUnformatted(std::ostream &o, const VectorBase< E > &v)
Specialize for VectorBase<E> to delegate to element type E, with spaces separating the elements.
Definition: BigMatrix.h:1183
VectorBase & resizeKeep(int m)
Definition: VectorBase.h:452
VectorBase & resize(int m)
Definition: VectorBase.h:451
int nrow() const
Definition: VectorBase.h:401
(Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignm...
Definition: VectorView_.h:42
std::istream & operator>>(std::istream &in, VectorView_< T > &out)
Read a (fixed size n) VectorView_<T> from a stream as a sequence of space- or comma-separated values ...
Definition: BigMatrix.h:1463
void writeUnformatted(std::ostream &o, const VectorView_< E > &v)
Raw serialization of VectorView_<E>; same as VectorBase<E>.
Definition: BigMatrix.h:1193
static std::istream & fillVectorViewFromStream(std::istream &in, VectorView_< T > &out)
Read in a fixed number of elements from a stream into an VectorView.
Definition: BigMatrix.h:1438
bool readUnformatted(std::istream &in, VectorView_< E > &v)
Read fixed-size VectorView from input stream.
Definition: BigMatrix.h:1248
This is the vector class intended to appear in user code for large, variable size column vectors.
Definition: Vector_.h:50
void writeUnformatted(std::ostream &o, const Vector_< E > &v)
Raw serialization of Vector_<E>; same as VectorBase<E>.
Definition: BigMatrix.h:1199
bool readUnformatted(std::istream &in, Vector_< E > &v)
Read variable-size Vector from input stream.
Definition: BigMatrix.h:1257
std::istream & operator>>(std::istream &in, Vector_< T > &out)
Read Vector_<T> from a stream as a sequence of space- or comma-separated values of type T,...
Definition: BigMatrix.h:1452
static std::istream & readVectorFromStream(std::istream &in, Vector_< T > &out)
Read in a Vector_<T> from a stream, as a sequence of space-separated or comma-separated values option...
Definition: BigMatrix.h:1400
static std::istream & fillVectorFromStream(std::istream &in, Vector_< T > &out)
Read in a fixed number of elements from a stream into a Vector.
Definition: BigMatrix.h:1430
Matrix_< Real > Matrix
Variable-size 2D matrix of Real elements; abbreviation for Matrix_<Real>.
Definition: BigMatrix.h:1478
RowVector_< Real > RowVector
Variable-size row vector of Real elements; abbreviation for RowVector_<Real>.
Definition: BigMatrix.h:1483
Vector_< Real > Vector
Variable-size column vector of Real elements; abbreviation for Vector_<Real>.
Definition: BigMatrix.h:1473
Matrix_< Complex > ComplexMatrix
Variable-size 2D matrix of Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1491
Vector_< fComplex > fComplexVector
Abbreviation for Vector_<std::complex<float>>.
Definition: BigMatrix.h:1514
VectorView_< fComplex > fComplexVectorView
Abbreviation for VectorView_<std::complex<float>>.
Definition: BigMatrix.h:1523
Matrix_< dComplex > dComplexMatrix
Abbreviation for Matrix_<std::complex<double>>.
Definition: BigMatrix.h:1552
MatrixView_< fComplex > fComplexMatrixView
Abbreviation for MatrixView_<std::complex<float>>.
Definition: BigMatrix.h:1559
VectorView_< float > fVectorView
Abbreviation for VectorView_<float>.
Definition: BigMatrix.h:1519
Matrix_< float > fMatrix
Abbreviation for Matrix_<float>.
Definition: BigMatrix.h:1546
RowVector_< dComplex > dComplexRowVector
Abbreviation for RowVector_<std::complex<double>>.
Definition: BigMatrix.h:1534
MatrixView_< dComplex > dComplexMatrixView
Abbreviation for MatrixView_<std::complex<double>>.
Definition: BigMatrix.h:1561
RowVectorView_< double > dRowVectorView
Abbreviation for RowVectorView_<double>.
Definition: BigMatrix.h:1539
MatrixView_< double > dMatrixView
Abbreviation for MatrixView_<double>.
Definition: BigMatrix.h:1557
Matrix_< fComplex > fComplexMatrix
Abbreviation for Matrix_<std::complex<float>>.
Definition: BigMatrix.h:1550
MatrixView_< float > fMatrixView
Abbreviation for MatrixView_<float>.
Definition: BigMatrix.h:1555
Vector_< double > dVector
Abbreviation for Vector_<double>.
Definition: BigMatrix.h:1512
RowVector_< float > fRowVector
Abbreviation for RowVector_<float>.
Definition: BigMatrix.h:1528
RowVectorView_< dComplex > dComplexRowVectorView
Abbreviation for RowVectorView_<std::complex<double>>.
Definition: BigMatrix.h:1543
VectorView_< Real > VectorView
Non-owner column vector sharing Real elements.
Definition: BigMatrix.h:1496
RowVectorView_< Complex > ComplexRowVectorView
Non-owner row vector sharing Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1507
RowVector_< fComplex > fComplexRowVector
Abbreviation for RowVector_<std::complex<float>>.
Definition: BigMatrix.h:1532
RowVector_< double > dRowVector
Abbreviation for RowVector_<double>.
Definition: BigMatrix.h:1530
VectorView_< Complex > ComplexVectorView
Non-owner column vector sharing Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1503
RowVectorView_< float > fRowVectorView
Abbreviation for RowVectorView_<float>.
Definition: BigMatrix.h:1537
MatrixView_< Real > MatrixView
Non-owner matrix sharing Real elements.
Definition: BigMatrix.h:1498
MatrixView_< Complex > ComplexMatrixView
Non-owner matrix sharing Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1505
VectorView_< double > dVectorView
Abbreviation for VectorView_<double>.
Definition: BigMatrix.h:1521
Vector_< dComplex > dComplexVector
Abbreviation for Vector_<std::complex<double>>.
Definition: BigMatrix.h:1516
RowVectorView_< Real > RowVectorView
Non-owner row vector sharing Real elements.
Definition: BigMatrix.h:1500
Matrix_< double > dMatrix
Abbreviation for Matrix_<double>.
Definition: BigMatrix.h:1548
RowVector_< Complex > ComplexRowVector
Variable-size row vector of Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1493
Vector_< float > fVector
Abbreviation for Vector_<float>.
Definition: BigMatrix.h:1510
RowVectorView_< fComplex > fComplexRowVectorView
Abbreviation for RowVectorView_<std::complex<float>>.
Definition: BigMatrix.h:1541
Vector_< Complex > ComplexVector
Variable-size column vector of Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1489
VectorView_< dComplex > dComplexVectorView
Abbreviation for VectorView_<std::complex<double>>.
Definition: BigMatrix.h:1525
bool readUnformatted(std::istream &in, T &v)
The default implementation of readUnformatted<T> reads in the next whitespace-separated token and the...
Definition: Serialize.h:176
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
Matrix_< E > operator*(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:605
static std::istream & readVectorFromStreamHelper(std::istream &in, bool isFixedSize, Vector_< T > &out)
Definition: BigMatrix.h:978
Matrix_< E > operator/(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:613
Matrix_< typename CNT< E1 >::template Result< E2 >::Add > operator+(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:568
std::ostream & operator<<(std::ostream &o, const ContactForce &f)
Definition: CompliantContactSubsystem.h:387
Matrix_< typename CNT< E1 >::template Result< E2 >::Sub > operator-(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:584
ELEM sum(const VectorBase< ELEM > &v)
Definition: VectorMath.h:147
Definition: MatrixBase.h:128