Simbody  3.8
BigMatrix.h
Go to the documentation of this file.
1 #ifndef SimTK_SIMMATRIX_BIGMATRIX_H_
2 #define SimTK_SIMMATRIX_BIGMATRIX_H_
3 
4 /* -------------------------------------------------------------------------- *
5  * Simbody(tm): SimTKcommon *
6  * -------------------------------------------------------------------------- *
7  * This is part of the SimTK biosimulation toolkit originating from *
8  * Simbios, the NIH National Center for Physics-Based Simulation of *
9  * Biological Structures at Stanford, funded under the NIH Roadmap for *
10  * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11  * *
12  * Portions copyright (c) 2005-13 Stanford University and the Authors. *
13  * Authors: Michael Sherman *
14  * Contributors: *
15  * *
16  * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17  * not use this file except in compliance with the License. You may obtain a *
18  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19  * *
20  * Unless required by applicable law or agreed to in writing, software *
21  * distributed under the License is distributed on an "AS IS" BASIS, *
22  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23  * See the License for the specific language governing permissions and *
24  * limitations under the License. *
25  * -------------------------------------------------------------------------- */
26 
150 #include "SimTKcommon/Scalar.h"
151 #include "SimTKcommon/SmallMatrix.h"
152 
155 
156 #include <iostream>
157 #include <cassert>
158 #include <complex>
159 #include <cstddef>
160 #include <limits>
161 
162 namespace SimTK {
163  template <class ELT> class MatrixBase;
164  template <class ELT> class VectorBase;
165  template <class ELT> class RowVectorBase;
166 
167  template <class ELT = Real> class MatrixView_;
168  template <class ELT = Real> class Matrix_;
169 
170  template <class ELT = Real> class VectorView_;
171  template <class ELT = Real> class Vector_;
172 
173  template <class ELT = Real> class RowVectorView_;
174  template <class ELT = Real> class RowVector_;
175 
176  template <class ELT, class VECTOR_CLASS> class VectorIterator;
177 }
178 
182 
185 
188 
191 
193 
194 
195 namespace SimTK {
196 
197 // ------------------------ MatrixBase definitions ----------------------------
198 
199 template <class ELT> inline MatrixView_<ELT>
200 MatrixBase<ELT>::block(int i, int j, int m, int n) const {
201  SimTK_INDEXCHECK(i,nrow()+1,"MatrixBase::block()");
202  SimTK_INDEXCHECK(j,ncol()+1,"MatrixBase::block()");
203  SimTK_SIZECHECK(i+m,nrow(),"MatrixBase::block()");
204  SimTK_SIZECHECK(j+n,ncol(),"MatrixBase::block()");
205 
206  MatrixHelper<Scalar> h(MatrixCommitment(),helper,i,j,m,n);
207  return MatrixView_<ELT>(h.stealRep());
208 }
209 
210 template <class ELT> inline MatrixView_<ELT>
211 MatrixBase<ELT>::updBlock(int i, int j, int m, int n) {
212  SimTK_INDEXCHECK(i,nrow()+1,"MatrixBase::updBlock()");
213  SimTK_INDEXCHECK(j,ncol()+1,"MatrixBase::updBlock()");
214  SimTK_SIZECHECK(i+m,nrow(),"MatrixBase::updBlock()");
215  SimTK_SIZECHECK(j+n,ncol(),"MatrixBase::updBlock()");
216 
217  MatrixHelper<Scalar> h(MatrixCommitment(),helper,i,j,m,n);
218  return MatrixView_<ELT>(h.stealRep());
219 }
220 
221 template <class E> inline MatrixView_<typename CNT<E>::THerm>
224  h(MatrixCommitment(),
225  helper, typename MatrixHelper<typename CNT<Scalar>::THerm>::TransposeView());
227 }
228 
229 template <class E> inline MatrixView_<typename CNT<E>::THerm>
232  h(MatrixCommitment(),
233  helper, typename MatrixHelper<typename CNT<Scalar>::THerm>::TransposeView());
235 }
236 
237 template <class E> inline VectorView_<E>
240  helper, typename MatrixHelper<Scalar>::DiagonalView());
241  return VectorView_<E>(h.stealRep());
242 }
243 
244 template <class E> inline VectorView_<E>
247  helper, typename MatrixHelper<Scalar>::DiagonalView());
248  return VectorView_<E>(h.stealRep());
249 }
250 
251 template <class ELT> inline VectorView_<ELT>
252 MatrixBase<ELT>::col(int j) const {
253  SimTK_INDEXCHECK(j,ncol(),"MatrixBase::col()");
254 
256  helper,0,j,nrow(),1);
257  return VectorView_<ELT>(h.stealRep());
258 }
259 
260 template <class ELT> inline VectorView_<ELT>
262  SimTK_INDEXCHECK(j,ncol(),"MatrixBase::updCol()");
263 
265  helper,0,j,nrow(),1);
266  return VectorView_<ELT>(h.stealRep());
267 }
268 
269 template <class ELT> inline RowVectorView_<ELT>
270 MatrixBase<ELT>::row(int i) const {
271  SimTK_INDEXCHECK(i,nrow(),"MatrixBase::row()");
272 
274  helper,i,0,1,ncol());
275  return RowVectorView_<ELT>(h.stealRep());
276 }
277 
278 template <class ELT> inline RowVectorView_<ELT>
280  SimTK_INDEXCHECK(i,nrow(),"MatrixBase::updRow()");
281 
283  helper,i,0,1,ncol());
284  return RowVectorView_<ELT>(h.stealRep());
285 }
286 
287 // M = diag(v) * M; v must have nrow() elements.
288 // That is, M[i] *= v[i].
289 template <class ELT> template <class EE> inline MatrixBase<ELT>&
291  assert(v.nrow() == nrow());
292  for (int i=0; i < nrow(); ++i)
293  (*this)[i] *= v[i];
294  return *this;
295 }
296 
297 template <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];
304 }
305 
306 // M = M * diag(v); v must have ncol() elements
307 // That is, M(i) *= v[i]
308 template <class ELT> template <class EE> inline MatrixBase<ELT>&
310  assert(v.nrow() == ncol());
311  for (int j=0; j < ncol(); ++j)
312  (*this)(j) *= v[j];
313  return *this;
314 }
315 
316 template <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];
323 }
324 
325 
326 // M(i,j) *= r[i]*c[j]; r must have nrow() elements; c must have ncol() elements
327 template <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]);
333  return *this;
334 }
335 
336 template <class ELT> template <class ER, class EC> inline void
338  const VectorBase<ER>& r,
339  const VectorBase<EC>& c,
340  typename EltResult<typename VectorBase<ER>::template EltResult<EC>::Mul>::Mul&
341  out) const
342 {
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]);
348 }
349 
350 // M(i,j) = s
351 template <class ELT> template <class S> inline MatrixBase<ELT>&
353  for (int j=0; j<ncol(); ++j)
354  for (int i=0; i<nrow(); ++i)
355  (*this)(i,j) = s;
356  return *this;
357 }
358 
359 // Set M(i,j) = M(i,j)^-1.
360 template <class ELT> inline MatrixBase<ELT>&
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);
366  e = CNT<ELT>::invert(e);
367  }
368  return *this;
369 }
370 
371 template <class ELT> inline void
373  const int nr=nrow(), nc=ncol();
374  out.resize(nr,nc);
375  for (int j=0; j<nc; ++j)
376  for (int i=0; i<nr; ++i)
377  out(i,j) = CNT<ELT>::invert((*this)(i,j));
378 }
379 
380 // M(i,j) += s
381 template <class ELT> template <class S> inline MatrixBase<ELT>&
383  for (int j=0; j<ncol(); ++j)
384  for (int i=0; i<nrow(); ++i)
385  (*this)(i,j) += s;
386  return *this;
387 }
388 
389 template <class ELT> template <class S> inline void
391  const S& s,
392  typename MatrixBase<ELT>::template EltResult<S>::Add& out) const
393 {
394  const int nr=nrow(), nc=ncol();
395  out.resize(nr,nc);
396  for (int j=0; j<nc; ++j)
397  for (int i=0; i<nr; ++i)
398  out(i,j) = (*this)(i,j) + s;
399 }
400 
401 // M(i,j) -= s
402 template <class ELT> template <class S> inline MatrixBase<ELT>&
404  for (int j=0; j<ncol(); ++j)
405  for (int i=0; i<nrow(); ++i)
406  (*this)(i,j) -= s;
407  return *this;
408 }
409 
410 template <class ELT> template <class S> inline void
412  const S& s,
413  typename MatrixBase<ELT>::template EltResult<S>::Sub& out) const
414 {
415  const int nr=nrow(), nc=ncol();
416  out.resize(nr,nc);
417  for (int j=0; j<nc; ++j)
418  for (int i=0; i<nr; ++i)
419  out(i,j) = (*this)(i,j) - s;
420 }
421 
422 // M(i,j) = s - M(i,j)
423 template <class ELT> template <class S> inline MatrixBase<ELT>&
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);
429  e = s - e;
430  }
431  return *this;
432 }
433 
434 template <class ELT> template <class S> inline void
436  const S& s,
437  typename MatrixBase<S>::template EltResult<ELT>::Sub& out) const
438 {
439  const int nr=nrow(), nc=ncol();
440  out.resize(nr,nc);
441  for (int j=0; j<nc; ++j)
442  for (int i=0; i<nr; ++i)
443  out(i,j) = s - (*this)(i,j);
444 }
445 
446 // M(i,j) *= R(i,j); R must have same dimensions as this
447 template <class ELT> template <class EE> inline MatrixBase<ELT>&
449  const int nr=nrow(), nc=ncol();
450  assert(r.nrow()==nr && r.ncol()==nc);
451  for (int j=0; j<nc; ++j)
452  for (int i=0; i<nr; ++i)
453  (*this)(i,j) *= r(i,j);
454  return *this;
455 }
456 
457 template <class ELT> template <class EE> inline void
459  const MatrixBase<EE>& r,
460  typename MatrixBase<ELT>::template EltResult<EE>::Mul& out) const
461 {
462  const int nr=nrow(), nc=ncol();
463  assert(r.nrow()==nr && r.ncol()==nc);
464  out.resize(nr,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);
468 }
469 
470 // M(i,j) = R(i,j) * M(i,j); R must have same dimensions as this
471 template <class ELT> template <class EE> inline MatrixBase<ELT>&
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);
478  e = r(i,j) * e;
479  }
480  return *this;
481 }
482 
483 template <class ELT> template <class EE> inline void
485  const MatrixBase<EE>& r,
486  typename MatrixBase<EE>::template EltResult<ELT>::Mul& out) const
487 {
488  const int nr=nrow(), nc=ncol();
489  assert(r.nrow()==nr && r.ncol()==nc);
490  out.resize(nr,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);
494 }
495 
496 // M(i,j) /= R(i,j); R must have same dimensions as this
497 template <class ELT> template <class EE> inline MatrixBase<ELT>&
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);
504  return *this;
505 }
506 
507 template <class ELT> template <class EE> inline void
509  const MatrixBase<EE>& r,
510  typename MatrixBase<ELT>::template EltResult<EE>::Dvd& out) const
511 {
512  const int nr=nrow(), nc=ncol();
513  assert(r.nrow()==nr && r.ncol()==nc);
514  out.resize(nr,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);
518 }
519 // M(i,j) = R(i,j) / M(i,j); R must have same dimensions as this
520 template <class ELT> template <class EE> inline MatrixBase<ELT>&
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);
527  e = r(i,j) / e;
528  }
529  return *this;
530 }
531 
532 template <class ELT> template <class EE> inline void
534  const MatrixBase<EE>& r,
535  typename MatrixBase<EE>::template EltResult<ELT>::Dvd& out) const
536 {
537  const int nr=nrow(), nc=ncol();
538  assert(r.nrow()==nr && r.ncol()==nc);
539  out.resize(nr,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);
543 }
544 
545 /*
546 template <class ELT> inline MatrixView_< typename CNT<ELT>::TReal >
547 MatrixBase<ELT>::real() const {
548  if (!CNT<ELT>::IsComplex) { // known at compile time
549  return MatrixView_< typename CNT<ELT>::TReal >( // this is just ELT
550  MatrixHelper(helper,0,0,nrow(),ncol())); // a view of the whole matrix
551  }
552  // Elements are complex -- helper uses underlying precision (real) type.
553  MatrixHelper<Precision> h(helper,typename MatrixHelper<Precision>::RealView);
554  return MatrixView_< typename CNT<ELT>::TReal >(h);
555 }
556 */
557 
558 
559 // ----------------------------------------------------------------------------
563 
564 // + and - allow mixed element types, but will fail to compile if the elements aren't
565 // compatible. At run time these will fail if the dimensions are incompatible.
566 template <class E1, class E2>
567 Matrix_<typename CNT<E1>::template Result<E2>::Add>
569  return Matrix_<typename CNT<E1>::template Result<E2>::Add>(l) += r;
570 }
571 
572 template <class E>
573 Matrix_<E> operator+(const MatrixBase<E>& l, const typename CNT<E>::T& r) {
574  return Matrix_<E>(l) += r;
575 }
576 
577 template <class E>
578 Matrix_<E> operator+(const typename CNT<E>::T& l, const MatrixBase<E>& r) {
579  return Matrix_<E>(r) += l;
580 }
581 
582 template <class E1, class E2>
583 Matrix_<typename CNT<E1>::template Result<E2>::Sub>
585  return Matrix_<typename CNT<E1>::template Result<E2>::Sub>(l) -= r;
586 }
587 
588 template <class E>
589 Matrix_<E> operator-(const MatrixBase<E>& l, const typename CNT<E>::T& r) {
590  return Matrix_<E>(l) -= r;
591 }
592 
593 template <class E>
594 Matrix_<E> operator-(const typename CNT<E>::T& l, const MatrixBase<E>& r) {
595  Matrix_<E> temp(r.nrow(), r.ncol());
596  temp = l;
597  return (temp -= r);
598 }
599 
600 // Scalar multiply and divide. You might wish the scalar could be
601 // a templatized type "E2", but that would create horrible ambiguities since
602 // E2 would match not only scalar types but everything else including
603 // matrices.
604 template <class E> Matrix_<E>
605 operator*(const MatrixBase<E>& l, const typename CNT<E>::StdNumber& r)
606  { return Matrix_<E>(l)*=r; }
607 
608 template <class E> Matrix_<E>
609 operator*(const typename CNT<E>::StdNumber& l, const MatrixBase<E>& r)
610  { return Matrix_<E>(r)*=l; }
611 
612 template <class E> Matrix_<E>
613 operator/(const MatrixBase<E>& l, const typename CNT<E>::StdNumber& r)
614  { return Matrix_<E>(l)/=r; }
615 
616 // Handle ints explicitly.
617 template <class E> Matrix_<E>
618 operator*(const MatrixBase<E>& l, int r)
619  { return Matrix_<E>(l)*= typename CNT<E>::StdNumber(r); }
620 
621 template <class E> Matrix_<E>
622 operator*(int l, const MatrixBase<E>& r)
623  { return Matrix_<E>(r)*= typename CNT<E>::StdNumber(l); }
624 
625 template <class E> Matrix_<E>
626 operator/(const MatrixBase<E>& l, int r)
627  { return Matrix_<E>(l)/= typename CNT<E>::StdNumber(r); }
628 
630 
634 
635 template <class E1, class E2>
636 Vector_<typename CNT<E1>::template Result<E2>::Add>
638  return Vector_<typename CNT<E1>::template Result<E2>::Add>(l) += r;
639 }
640 template <class E>
641 Vector_<E> operator+(const VectorBase<E>& l, const typename CNT<E>::T& r) {
642  return Vector_<E>(l) += r;
643 }
644 template <class E>
645 Vector_<E> operator+(const typename CNT<E>::T& l, const VectorBase<E>& r) {
646  return Vector_<E>(r) += l;
647 }
648 template <class E1, class E2>
649 Vector_<typename CNT<E1>::template Result<E2>::Sub>
651  return Vector_<typename CNT<E1>::template Result<E2>::Sub>(l) -= r;
652 }
653 template <class E>
654 Vector_<E> operator-(const VectorBase<E>& l, const typename CNT<E>::T& r) {
655  return Vector_<E>(l) -= r;
656 }
657 template <class E>
658 Vector_<E> operator-(const typename CNT<E>::T& l, const VectorBase<E>& r) {
659  Vector_<E> temp(r.size());
660  temp = l;
661  return (temp -= r);
662 }
663 
664 // Scalar multiply and divide.
665 
666 template <class E> Vector_<E>
667 operator*(const VectorBase<E>& l, const typename CNT<E>::StdNumber& r)
668  { return Vector_<E>(l)*=r; }
669 
670 template <class E> Vector_<E>
671 operator*(const typename CNT<E>::StdNumber& l, const VectorBase<E>& r)
672  { return Vector_<E>(r)*=l; }
673 
674 template <class E> Vector_<E>
675 operator/(const VectorBase<E>& l, const typename CNT<E>::StdNumber& r)
676  { return Vector_<E>(l)/=r; }
677 
678 // Handle ints explicitly
679 template <class E> Vector_<E>
680 operator*(const VectorBase<E>& l, int r)
681  { return Vector_<E>(l)*= typename CNT<E>::StdNumber(r); }
682 
683 template <class E> Vector_<E>
684 operator*(int l, const VectorBase<E>& r)
685  { return Vector_<E>(r)*= typename CNT<E>::StdNumber(l); }
686 
687 template <class E> Vector_<E>
688 operator/(const VectorBase<E>& l, int r)
689  { return Vector_<E>(l)/= typename CNT<E>::StdNumber(r); }
690 
691 // These are fancier "scalars"; whether they are allowed depends on
692 // whether the element type and the CNT are compatible.
693 
694 // Vector * Vec
695 template <class E1, int M, class E2, int S>
696 Vector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul>
697 operator*(const VectorBase<E1>& v, const Vec<M,E2,S>& s) {
698  Vector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul> res(v.nrow());
699  for (int i=0; i < v.nrow(); ++i)
700  res[i] = v[i]*s;
701  return res;
702 }
703 
704 // Vec * Vector
705 template <class E1, int M, class E2, int S>
706 Vector_<typename Vec<M,E2,S>::template Result<E1>::Mul>
707 operator*(const Vec<M,E2,S>& s, const VectorBase<E1>& v) {
708  Vector_<typename Vec<M,E2,S>::template Result<E1>::Mul> res(v.nrow());
709  for (int i=0; i < v.nrow(); ++i)
710  res[i] = s*v[i];
711  return res;
712 }
713 
714 // Vector * Row
715 template <class E1, int N, class E2, int S>
716 Vector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul>
717 operator*(const VectorBase<E1>& v, const Row<N,E2,S>& s) {
718  Vector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul> res(v.nrow());
719  for (int i=0; i < v.nrow(); ++i)
720  res[i] = v[i]*s;
721  return res;
722 }
723 
724 // Row * Vector
725 template <class E1, int N, class E2, int S>
726 Vector_<typename Row<N,E2,S>::template Result<E1>::Mul>
727 operator*(const Row<N,E2,S>& s, const VectorBase<E1>& v) {
728  Vector_<typename Row<N,E2,S>::template Result<E1>::Mul> res(v.nrow());
729  for (int i=0; i < v.nrow(); ++i)
730  res[i] = s*v[i];
731  return res;
732 }
733 
734 // Vector * Mat
735 template <class E1, int M, int N, class E2, int S1, int S2>
736 Vector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul>
738  Vector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul> res(v.nrow());
739  for (int i=0; i < v.nrow(); ++i)
740  res[i] = v[i]*s;
741  return res;
742 }
743 
744 // Mat * Vector
745 template <class E1, int M, int N, class E2, int S1, int S2>
746 Vector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul>
748  Vector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul> res(v.nrow());
749  for (int i=0; i < v.nrow(); ++i)
750  res[i] = s*v[i];
751  return res;
752 }
753 
754 // Vector * SymMat
755 template <class E1, int M, class E2, int S>
756 Vector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul>
758  Vector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul> res(v.nrow());
759  for (int i=0; i < v.nrow(); ++i)
760  res[i] = v[i]*s;
761  return res;
762 }
763 
764 // SymMat * Vector
765 template <class E1, int M, class E2, int S>
766 Vector_<typename SymMat<M,E2,S>::template Result<E1>::Mul>
768  Vector_<typename SymMat<M,E2,S>::template Result<E1>::Mul> res(v.nrow());
769  for (int i=0; i < v.nrow(); ++i)
770  res[i] = s*v[i];
771  return res;
772 }
773 
775 
779 
780 template <class E1, class E2>
781 RowVector_<typename CNT<E1>::template Result<E2>::Add>
783  return RowVector_<typename CNT<E1>::template Result<E2>::Add>(l) += r;
784 }
785 template <class E>
786 RowVector_<E> operator+(const RowVectorBase<E>& l, const typename CNT<E>::T& r) {
787  return RowVector_<E>(l) += r;
788 }
789 template <class E>
790 RowVector_<E> operator+(const typename CNT<E>::T& l, const RowVectorBase<E>& r) {
791  return RowVector_<E>(r) += l;
792 }
793 template <class E1, class E2>
794 RowVector_<typename CNT<E1>::template Result<E2>::Sub>
796  return RowVector_<typename CNT<E1>::template Result<E2>::Sub>(l) -= r;
797 }
798 template <class E>
799 RowVector_<E> operator-(const RowVectorBase<E>& l, const typename CNT<E>::T& r) {
800  return RowVector_<E>(l) -= r;
801 }
802 template <class E>
803 RowVector_<E> operator-(const typename CNT<E>::T& l, const RowVectorBase<E>& r) {
804  RowVector_<E> temp(r.size());
805  temp = l;
806  return (temp -= r);
807 }
808 
809 // Scalar multiply and divide
810 
811 template <class E> RowVector_<E>
812 operator*(const RowVectorBase<E>& l, const typename CNT<E>::StdNumber& r)
813  { return RowVector_<E>(l)*=r; }
814 
815 template <class E> RowVector_<E>
816 operator*(const typename CNT<E>::StdNumber& l, const RowVectorBase<E>& r)
817  { return RowVector_<E>(r)*=l; }
818 
819 template <class E> RowVector_<E>
820 operator/(const RowVectorBase<E>& l, const typename CNT<E>::StdNumber& r)
821  { return RowVector_<E>(l)/=r; }
822 
823 // Handle ints explicitly.
824 template <class E> RowVector_<E>
825 operator*(const RowVectorBase<E>& l, int r)
826  { return RowVector_<E>(l)*= typename CNT<E>::StdNumber(r); }
827 
828 template <class E> RowVector_<E>
829 operator*(int l, const RowVectorBase<E>& r)
830  { return RowVector_<E>(r)*= typename CNT<E>::StdNumber(l); }
831 
832 template <class E> RowVector_<E>
833 operator/(const RowVectorBase<E>& l, int r)
834  { return RowVector_<E>(l)/= typename CNT<E>::StdNumber(r); }
835 
836 
837 // These are fancier "scalars"; whether they are allowed depends on
838 // whether the element type and the CNT are compatible.
839 
840 // RowVector * Vec
841 template <class E1, int M, class E2, int S>
842 RowVector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul>
844  RowVector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul> res(v.ncol());
845  for (int i=0; i < v.ncol(); ++i)
846  res[i] = v[i]*s;
847  return res;
848 }
849 
850 // Vec * RowVector
851 template <class E1, int M, class E2, int S>
852 RowVector_<typename Vec<M,E2,S>::template Result<E1>::Mul>
854  RowVector_<typename Vec<M,E2,S>::template Result<E1>::Mul> res(v.ncol());
855  for (int i=0; i < v.ncol(); ++i)
856  res[i] = s*v[i];
857  return res;
858 }
859 
860 // RowVector * Row
861 template <class E1, int N, class E2, int S>
862 RowVector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul>
864  RowVector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul> res(v.ncol());
865  for (int i=0; i < v.ncol(); ++i)
866  res[i] = v[i]*s;
867  return res;
868 }
869 
870 // Row * RowVector
871 template <class E1, int N, class E2, int S>
872 RowVector_<typename Row<N,E2,S>::template Result<E1>::Mul>
874  RowVector_<typename Row<N,E2,S>::template Result<E1>::Mul> res(v.ncol());
875  for (int i=0; i < v.ncol(); ++i)
876  res[i] = s*v[i];
877  return res;
878 }
879 
880 // RowVector * Mat
881 template <class E1, int M, int N, class E2, int S1, int S2>
882 RowVector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul>
884  RowVector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul> res(v.ncol());
885  for (int i=0; i < v.ncol(); ++i)
886  res[i] = v[i]*s;
887  return res;
888 }
889 
890 // Mat * RowVector
891 template <class E1, int M, int N, class E2, int S1, int S2>
892 RowVector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul>
894  RowVector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul> res(v.ncol());
895  for (int i=0; i < v.ncol(); ++i)
896  res[i] = s*v[i];
897  return res;
898 }
899 
900 // RowVector * SymMat
901 template <class E1, int M, class E2, int S>
902 RowVector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul>
904  RowVector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul> res(v.ncol());
905  for (int i=0; i < v.ncol(); ++i)
906  res[i] = v[i]*s;
907  return res;
908 }
909 
910 // SymMat * RowVector
911 template <class E1, int M, class E2, int S>
912 RowVector_<typename SymMat<M,E2,S>::template Result<E1>::Mul>
914  RowVector_<typename SymMat<M,E2,S>::template Result<E1>::Mul> res(v.ncol());
915  for (int i=0; i < v.ncol(); ++i)
916  res[i] = s*v[i];
917  return res;
918 }
919 
921 
922 
927 
928  // TODO: these should use LAPACK!
929 
930 // Dot product
931 template <class E1, class E2>
932 typename CNT<E1>::template Result<E2>::Mul
934  assert(r.ncol() == v.nrow());
935  typename CNT<E1>::template Result<E2>::Mul sum(0);
936  for (int j=0; j < r.ncol(); ++j)
937  sum += r(j) * v[j];
938  return sum;
939 }
940 
941 template <class E1, class E2>
942 Vector_<typename CNT<E1>::template Result<E2>::Mul>
944  assert(m.ncol() == v.nrow());
945  Vector_<typename CNT<E1>::template Result<E2>::Mul> res(m.nrow());
946  for (int i=0; i< m.nrow(); ++i)
947  res[i] = m[i]*v;
948  return res;
949 }
950 
951 template <class E1, class E2>
952 Matrix_<typename CNT<E1>::template Result<E2>::Mul>
953 operator*(const MatrixBase<E1>& m1, const MatrixBase<E2>& m2) {
954  assert(m1.ncol() == m2.nrow());
955  Matrix_<typename CNT<E1>::template Result<E2>::Mul>
956  res(m1.nrow(),m2.ncol());
957 
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);
961 
962  return res;
963 }
964 
966 
967 // This "private" static method is used to implement VectorView's
968 // fillVectorViewFromStream() and Vector's readVectorFromStream()
969 // namespace-scope static methods, which are in turn used to implement
970 // VectorView's and
971 // Vector's stream extraction operators ">>". This method has to be in the
972 // header file so that we don't need to pass streams through the API, but it
973 // is not intended for use by users and has no Doxygen presence, unlike
974 // fillArrayFromStream() and readArrayFromStream() and (more commonly)
975 // the extraction operators.
976 template <class T> static inline
978  (std::istream& in, bool isFixedSize, Vector_<T>& out)
979 {
980  // If already failed, bad, or eof, set failed bit and return without
981  // touching the Vector.
982  if (!in.good()) {in.setstate(std::ios::failbit); return in;}
983 
984  // If the passed-in Vector isn't resizeable, then we have to treat it as
985  // a fixed size VectorView regardless of the setting of the isFixedSize
986  // argument.
987  if (!out.isResizeable())
988  isFixedSize = true; // might be overriding the argument here
989 
990  // numRequired will be ignored unless isFixedSize==true.
991  const int numRequired = isFixedSize ? out.size() : 0;
992 
993  if (!isFixedSize)
994  out.clear(); // We're going to replace the entire contents of the Array.
995 
996  // Skip initial whitespace. If that results in eof this may be a successful
997  // read of a 0-length, unbracketed Vector. That is OK for either a
998  // variable-length Vector or a fixed-length VectorView of length zero.
999  std::ws(in); if (in.fail()) return in;
1000  if (in.eof()) {
1001  if (isFixedSize && numRequired != 0)
1002  in.setstate(std::ios_base::failbit); // zero elements not OK
1003  return in;
1004  }
1005 
1006  // Here the stream is good and the next character is non-white.
1007  assert(in.good());
1008 
1009  // Use this for raw i/o (peeks and gets).
1010  typename std::iostream::int_type ch;
1011 #ifndef NDEBUG
1012  const typename std::iostream::int_type EOFch =
1013  std::iostream::traits_type::eof();
1014 #endif
1015 
1016  // First we'll look for the optional "~". If found, the brackets become
1017  // required.
1018  bool tildeFound = false;
1019  ch = in.peek(); if (in.fail()) return in;
1020  assert(ch != EOFch); // we already checked above
1021  if ((char)ch == '~') {
1022  tildeFound = true;
1023  in.get(); // absorb the tilde
1024  // Eat whitespace after the tilde to see what's next.
1025  if (in.good()) std::ws(in);
1026  // If we hit eof after the tilde we don't like the formatting.
1027  if (!in.good()) {in.setstate(std::ios_base::failbit); return in;}
1028  }
1029 
1030  // Here the stream is good, the next character is non-white, and we
1031  // might have seen a tilde.
1032  assert(in.good());
1033 
1034  // Now see if the sequence is bare or surrounded by (), or [].
1035  bool lookForCloser = true;
1036  char openBracket, closeBracket;
1037  ch = in.peek(); if (in.fail()) return in;
1038  assert(ch != EOFch); // we already checked above
1039 
1040  openBracket = (char)ch;
1041  if (openBracket=='(') {in.get(); closeBracket = ')';}
1042  else if (openBracket=='[') {in.get(); closeBracket = ']';}
1043  else lookForCloser = false;
1044 
1045  // If we found a tilde, the opening bracket was mandatory. If we didn't
1046  // find one then we reject the formatting.
1047  if (tildeFound && !lookForCloser)
1048  { in.setstate(std::ios_base::failbit); return in;}
1049 
1050  // If lookForCloser is true, then closeBracket contains the terminating
1051  // delimiter, otherwise we're not going to quit until eof.
1052 
1053  // Eat whitespace after the opening bracket to see what's next.
1054  if (in.good()) std::ws(in);
1055 
1056  // If we're at eof now it must be because the open bracket was the
1057  // last non-white character in the stream, which is an error.
1058  if (!in.good()) {
1059  if (in.eof()) {
1060  assert(lookForCloser); // or we haven't read anything that could eof
1061  in.setstate(std::ios::failbit);
1062  }
1063  return in;
1064  }
1065 
1066  // istream is good and next character is non-white; ready to read first
1067  // value or terminator.
1068 
1069  // We need to figure out whether the elements are space- or comma-
1070  // separated and then insist on consistency.
1071  bool commaOK = true, commaRequired = false;
1072  bool terminatorSeen = false;
1073  int nextIndex = 0;
1074  while (true) {
1075  char c;
1076 
1077  // Here at the top of this loop, we have already successfully read
1078  // n=nextIndex values of type T. For fixed-size reads, it might be
1079  // the case that n==numRequired already, but we still may need to
1080  // look for a closing bracket before we can declare victory.
1081  // The stream is good() (not at eof) but it might be the case that
1082  // there is nothing but white space left; we don't know yet because
1083  // if we have satisfied the fixed-size count and are not expecting
1084  // a terminator then we should quit without absorbing the trailing
1085  // white space.
1086  assert(in.good());
1087 
1088  // Look for closing bracket before trying to read value.
1089  if (lookForCloser) {
1090  // Eat white space to find the closing bracket.
1091  std::ws(in); if (!in.good()) break; // eof?
1092  ch = in.peek(); assert(ch != EOFch);
1093  if (!in.good()) break;
1094  c = (char)ch;
1095  if (c == closeBracket) {
1096  in.get(); // absorb the closing bracket
1097  terminatorSeen = true;
1098  break;
1099  }
1100  // next char not a closing bracket; fall through
1101  }
1102 
1103  // We didn't look or didn't find a closing bracket. The istream is good
1104  // but we might be looking at white space.
1105 
1106  // If we already got all the elements we want, break for final checks.
1107  if (isFixedSize && (nextIndex == numRequired))
1108  break; // that's a full count.
1109 
1110  // Look for comma before value, except the first time.
1111  if (commaOK && nextIndex != 0) {
1112  // Eat white space to find the comma.
1113  std::ws(in); if (!in.good()) break; // eof?
1114  ch = in.peek(); assert(ch != EOFch);
1115  if (!in.good()) break;
1116  c = (char)ch;
1117  if (c == ',') {
1118  in.get(); // absorb comma
1119  commaRequired = true; // all commas from now on
1120  } else { // next char not a comma
1121  if (commaRequired) // bad, e.g.: v1, v2, v3 v4
1122  { in.setstate(std::ios::failbit); break; }
1123  else commaOK = false; // saw: v1 v2 (no commas now)
1124  }
1125  if (!in.good()) break; // might be eof
1126  }
1127 
1128  // No closing bracket yet; don't have enough elements; skipped comma
1129  // if any; istream is good; might be looking at white space.
1130  assert(in.good());
1131 
1132  // Now read in an element of type T.
1133  // The extractor T::operator>>() will ignore leading white space.
1134  if (!isFixedSize && nextIndex >= out.size())
1135  {
1136  // grow output vector geometrically (resized to actual size after loop)
1137  out.resizeKeep(out.size() == 0 ? 1 : 2*out.size());
1138  }
1139  in >> out[nextIndex]; if (in.fail()) break;
1140  ++nextIndex;
1141 
1142  if (!in.good()) break; // might be eof
1143  }
1144  out.resizeKeep(nextIndex); // cut off trailing elements
1145 
1146  // We will get here under a number of circumstances:
1147  // - the fail bit is set in the istream, or
1148  // - we reached eof
1149  // - we saw a closing brace
1150  // - we got all the elements we wanted (for a fixed-size read)
1151  // Note that it is possible that we consumed everything except some
1152  // trailing white space (meaning we're not technically at eof), but
1153  // for consistency with built-in operator>>()'s we won't try to absorb
1154  // that trailing white space.
1155 
1156  if (!in.fail()) {
1157  if (lookForCloser && !terminatorSeen)
1158  in.setstate(std::ios::failbit); // missing terminator
1159 
1160  if (isFixedSize && nextIndex != numRequired)
1161  in.setstate(std::ios::failbit); // wrong number of values
1162  }
1163 
1164  return in;
1165 }
1166 
1167 
1168 
1169 //------------------------------------------------------------------------------
1170 // RELATED GLOBAL OPERATORS
1171 //------------------------------------------------------------------------------
1172 // These are logically part of the Matrix_<T> class but are not actually
1173 // class members; that is, they are in the SimTK namespace.
1174 
1186 template <class E> inline void
1187 writeUnformatted(std::ostream& o, const VectorBase<E>& v) {
1188  const int sz = v.size();
1189  for (int i=0; i < sz; ++i) {
1190  if (i != 0) o << " ";
1191  writeUnformatted(o, v[i]);
1192  }
1193 }
1196 template <class E> inline void
1197 writeUnformatted(std::ostream& o, const VectorView_<E>& v)
1198 { writeUnformatted(o, static_cast< const VectorBase<E> >(v)); }
1199 
1202 template <class E> inline void
1203 writeUnformatted(std::ostream& o, const Vector_<E>& v)
1204 { writeUnformatted(o, static_cast< const VectorBase<E> >(v)); }
1205 
1209 template <class E> inline void
1210 writeUnformatted(std::ostream& o, const RowVectorBase<E>& v)
1211 { writeUnformatted(o, ~v); }
1212 
1215 template <class E> inline void
1216 writeUnformatted(std::ostream& o, const RowVectorView_<E>& v)
1217 { writeUnformatted(o, static_cast< const RowVectorBase<E> >(v)); }
1218 
1221 template <class E> inline void
1222 writeUnformatted(std::ostream& o, const RowVector_<E>& v)
1223 { writeUnformatted(o, static_cast< const RowVectorBase<E> >(v)); }
1224 
1228 template <class E> inline void
1229 writeUnformatted(std::ostream& o, const MatrixBase<E>& v) {
1230  const int nr = v.nrow();
1231  for (int i=0; i < nr; ++i) {
1232  if (i != 0) o << std::endl;
1233  writeUnformatted(o, v[i]);
1234  }
1235 }
1238 template <class E> inline void
1239 writeUnformatted(std::ostream& o, const MatrixView_<E>& v)
1240 { writeUnformatted(o, static_cast< const MatrixBase<E> >(v)); }
1241 
1244 template <class E> inline void
1245 writeUnformatted(std::ostream& o, const Matrix_<E>& v)
1246 { writeUnformatted(o, static_cast< const MatrixBase<E> >(v)); }
1247 
1251 template <class E> inline bool
1252 readUnformatted(std::istream& in, VectorView_<E>& v) {
1253  for (int i=0; i < v.size(); ++i)
1254  if (!readUnformatted(in, v[i])) return false;
1255  return true;
1256 }
1257 
1260 template <class E> inline bool
1261 readUnformatted(std::istream& in, Vector_<E>& v) {
1262  if (!v.isResizeable())
1263  return readUnformatted(in, v.updAsVectorView());
1264 
1265  Array_<E,int> a;
1266  if (!readUnformatted(in,a)) return false;
1267  v.resize(a.size());
1268  for (int i=0; i<a.size(); ++i)
1269  v[i] = a[i];
1270  return true;
1271 }
1272 
1276 template <class E> inline bool
1277 readUnformatted(std::istream& in, RowVectorView_<E>& v)
1278 { VectorView_<E> vt(~v);
1279  return readUnformatted<E>(in, vt); }
1280 
1284 template <class E> inline bool
1285 readUnformatted(std::istream& in, RowVector_<E>& v)
1286 { Vector_<E> vt(~v);
1287  return readUnformatted<E>(in, vt); }
1288 
1294 template <class E> inline bool
1295 readUnformatted(std::istream& in, MatrixView_<E>& v) {
1296  for (int row=0; row < v.nrow(); ++row) {
1297  RowVectorView_<E> oneRow(v[row]);
1298  if (!readUnformatted<E>(in, oneRow)) return false;
1299  }
1300  return true;
1301 }
1302 
1308 template <class E> inline bool
1309 fillUnformatted(std::istream& in, Matrix_<E>& v) {
1310  return readUnformatted<E>(in, v.updAsMatrixView());
1311 }
1312 
1316 template <class E> inline bool
1317 readUnformatted(std::istream& in, Matrix_<E>& v) {
1318  SimTK_ASSERT_ALWAYS(!"implemented",
1319  "SimTK::readUnformatted(istream, Matrix) is not implemented; try"
1320  " SimTK::fillUnformatted(istream, Matrix) instead.");
1321  return false;
1322 }
1323 
1330 template <class T> inline std::ostream&
1331 operator<<(std::ostream& o, const VectorBase<T>& v)
1332 { o << "~[";
1333  if (v.size()) {
1334  o << v[0];
1335  for (int i=1; i < v.size(); ++i) o << " " << v[i];
1336  }
1337  return o << "]";
1338 }
1339 
1346 template <class T> inline std::ostream&
1347 operator<<(std::ostream& o, const RowVectorBase<T>& v)
1348 { o << "[";
1349  if (v.size()) {
1350  o << v[0];
1351  for (int i=1; i < v.size(); ++i) o << " " << v[i];
1352  }
1353  return o << "]";
1354 }
1355 
1363 template <class T> inline std::ostream&
1364 operator<<(std::ostream& o, const MatrixBase<T>& m) {
1365  for (int i=0;i<m.nrow();++i)
1366  o << std::endl << m[i];
1367  if (m.nrow()) o << std::endl;
1368  return o;
1369 }
1370 
1371 
1403 template <class T> static inline
1404 std::istream& readVectorFromStream(std::istream& in, Vector_<T>& out)
1405 { return readVectorFromStreamHelper<T>(in, false /*variable sizez*/, out); }
1406 
1407 
1408 
1433 template <class T> static inline
1434 std::istream& fillVectorFromStream(std::istream& in, Vector_<T>& out)
1435 { return readVectorFromStreamHelper<T>(in, true /*fixed size*/, out); }
1436 
1441 template <class T> static inline
1442 std::istream& fillVectorViewFromStream(std::istream& in, VectorView_<T>& out)
1443 { return readVectorFromStreamHelper<T>(in, true /*fixed size*/, out); }
1444 
1445 
1455 template <class T> inline
1456 std::istream& operator>>(std::istream& in, Vector_<T>& out)
1457 { return readVectorFromStream<T>(in, out); }
1458 
1466 template <class T> inline
1467 std::istream& operator>>(std::istream& in, VectorView_<T>& out)
1468 { return fillVectorViewFromStream<T>(in, out); } // End of Matrix serialization.
1470 
1471 // Friendly abbreviations for vectors and matrices with scalar elements.
1478 
1483 
1498 
1505 
1512 
1521 
1530 
1539 
1548 
1557 
1568 } //namespace SimTK
1569 
1570 #endif //SimTK_SIMMATRIX_BIGMATRIX_H_
#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
MatrixBase & elementwiseMultiplyInPlace(const MatrixBase< EE > &)
M(i,j) *= R(i,j); R must have same dimensions as this.
void elementwiseDivideFromLeft(const MatrixBase< EE > &, typename MatrixBase< EE >::template EltResult< E >::Dvd &) const
Definition: BigMatrix.h:533
MatrixBase & elementwiseMultiplyFromLeftInPlace(const MatrixBase< EE > &)
M(i,j) = R(i,j) * M(i,j); R must have same dimensions as this.
MatrixBase & elementwiseInvertInPlace()
Set M(i,j) = M(i,j)^-1.
Definition: BigMatrix.h:361
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 & rowAndColScaleInPlace(const VectorBase< ER > &r, const VectorBase< EC > &c)
M = diag(r) * M * diag(c); r must have nrow() elements; must have ncol() elements.
MatrixBase & elementwiseDivideFromLeftInPlace(const MatrixBase< EE > &)
M(i,j) = R(i,j) / M(i,j); R must have same dimensions as this.
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:1229
MatrixBase & resize(int m, int n)
Change the size of this matrix.
Definition: MatrixBase.h:773
MatrixView_< EHerm > updTranspose()
Definition: BigMatrix.h:230
void colScale(const VectorBase< EE > &c, typename EltResult< EE >::Mul &out) const
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
MatrixView_< ELT > & updAsMatrixView()
Definition: MatrixBase.h:793
MatrixBase & elementwiseDivideInPlace(const MatrixBase< EE > &)
M(i,j) /= R(i,j); R must have same dimensions as this.
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
MatrixBase & elementwiseSubtractScalarInPlace(const S &s)
Set M(i,j)-=s for every element of M and some value s.
MatrixBase & elementwiseSubtractFromScalarInPlace(const S &s)
Set M(i,j) = s - M(i,j) for every element of M and some value s.
void elementwiseDivide(const MatrixBase< EE > &, typename EltResult< EE >::Dvd &) const
MatrixBase & rowScaleInPlace(const VectorBase< EE > &)
M = diag(r) * M; r must have nrow() elements.
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...
void elementwiseMultiply(const MatrixBase< EE > &, typename EltResult< EE >::Mul &) const
VectorView_< ELT > col(int j) const
Definition: BigMatrix.h:252
VectorView_< ELT > & updAsVectorView()
Definition: MatrixBase.h:799
MatrixBase & colScaleInPlace(const VectorBase< EE > &)
M = M * diag(c); c must have ncol() elements.
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
MatrixBase & elementwiseAddScalarInPlace(const S &s)
Set M(i,j)+=s for every element of M and some value s.
MatrixBase< typename CNT< E >::TInvert > elementwiseInvert() const
Definition: MatrixBase.h:452
MatrixBase & elementwiseAssign(const S &s)
Set M(i,j)=s for every element of M and some value s.
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:1239
bool readUnformatted(std::istream &in, MatrixView_< E > &v)
Read fixed-size MatrixView in row order from unformatted (whitespace- separated) input stream.
Definition: BigMatrix.h:1295
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:1317
void writeUnformatted(std::ostream &o, const Matrix_< E > &v)
Raw serialization of Vector_<E>; same as VectorBase<E>.
Definition: BigMatrix.h:1245
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:1309
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:1210
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:1277
void writeUnformatted(std::ostream &o, const RowVectorView_< E > &v)
Raw serialization of RowVectorView_<E>; same as VectorView_<E>.
Definition: BigMatrix.h:1216
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:1222
bool readUnformatted(std::istream &in, RowVector_< E > &v)
Read variable-size RowVector from unformatted (whitespace-separated) input stream.
Definition: BigMatrix.h:1285
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:1187
VectorBase & resize(int m)
Definition: VectorBase.h:451
int nrow() const
Definition: VectorBase.h:401
VectorBase & resizeKeep(int m)
Definition: VectorBase.h:452
(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:1467
void writeUnformatted(std::ostream &o, const VectorView_< E > &v)
Raw serialization of VectorView_<E>; same as VectorBase<E>.
Definition: BigMatrix.h:1197
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:1442
bool readUnformatted(std::istream &in, VectorView_< E > &v)
Read fixed-size VectorView from input stream.
Definition: BigMatrix.h:1252
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:1203
bool readUnformatted(std::istream &in, Vector_< E > &v)
Read variable-size Vector from input stream.
Definition: BigMatrix.h:1261
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:1456
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:1404
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:1434
Matrix_< Real > Matrix
Variable-size 2D matrix of Real elements; abbreviation for Matrix_<Real>.
Definition: BigMatrix.h:1482
RowVector_< Real > RowVector
Variable-size row vector of Real elements; abbreviation for RowVector_<Real>.
Definition: BigMatrix.h:1487
Vector_< Real > Vector
Variable-size column vector of Real elements; abbreviation for Vector_<Real>.
Definition: BigMatrix.h:1477
Matrix_< Complex > ComplexMatrix
Variable-size 2D matrix of Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1495
Vector_< fComplex > fComplexVector
Abbreviation for Vector_<std::complex<float>>.
Definition: BigMatrix.h:1518
VectorView_< fComplex > fComplexVectorView
Abbreviation for VectorView_<std::complex<float>>.
Definition: BigMatrix.h:1527
Matrix_< dComplex > dComplexMatrix
Abbreviation for Matrix_<std::complex<double>>.
Definition: BigMatrix.h:1556
MatrixView_< fComplex > fComplexMatrixView
Abbreviation for MatrixView_<std::complex<float>>.
Definition: BigMatrix.h:1563
VectorView_< float > fVectorView
Abbreviation for VectorView_<float>.
Definition: BigMatrix.h:1523
Matrix_< float > fMatrix
Abbreviation for Matrix_<float>.
Definition: BigMatrix.h:1550
RowVector_< dComplex > dComplexRowVector
Abbreviation for RowVector_<std::complex<double>>.
Definition: BigMatrix.h:1538
MatrixView_< dComplex > dComplexMatrixView
Abbreviation for MatrixView_<std::complex<double>>.
Definition: BigMatrix.h:1565
RowVectorView_< double > dRowVectorView
Abbreviation for RowVectorView_<double>.
Definition: BigMatrix.h:1543
MatrixView_< double > dMatrixView
Abbreviation for MatrixView_<double>.
Definition: BigMatrix.h:1561
Matrix_< fComplex > fComplexMatrix
Abbreviation for Matrix_<std::complex<float>>.
Definition: BigMatrix.h:1554
MatrixView_< float > fMatrixView
Abbreviation for MatrixView_<float>.
Definition: BigMatrix.h:1559
Vector_< double > dVector
Abbreviation for Vector_<double>.
Definition: BigMatrix.h:1516
RowVector_< float > fRowVector
Abbreviation for RowVector_<float>.
Definition: BigMatrix.h:1532
RowVectorView_< dComplex > dComplexRowVectorView
Abbreviation for RowVectorView_<std::complex<double>>.
Definition: BigMatrix.h:1547
VectorView_< Real > VectorView
Non-owner column vector sharing Real elements.
Definition: BigMatrix.h:1500
RowVectorView_< Complex > ComplexRowVectorView
Non-owner row vector sharing Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1511
RowVector_< fComplex > fComplexRowVector
Abbreviation for RowVector_<std::complex<float>>.
Definition: BigMatrix.h:1536
RowVector_< double > dRowVector
Abbreviation for RowVector_<double>.
Definition: BigMatrix.h:1534
VectorView_< Complex > ComplexVectorView
Non-owner column vector sharing Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1507
RowVectorView_< float > fRowVectorView
Abbreviation for RowVectorView_<float>.
Definition: BigMatrix.h:1541
MatrixView_< Real > MatrixView
Non-owner matrix sharing Real elements.
Definition: BigMatrix.h:1502
MatrixView_< Complex > ComplexMatrixView
Non-owner matrix sharing Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1509
VectorView_< double > dVectorView
Abbreviation for VectorView_<double>.
Definition: BigMatrix.h:1525
Vector_< dComplex > dComplexVector
Abbreviation for Vector_<std::complex<double>>.
Definition: BigMatrix.h:1520
RowVectorView_< Real > RowVectorView
Non-owner row vector sharing Real elements.
Definition: BigMatrix.h:1504
Matrix_< double > dMatrix
Abbreviation for Matrix_<double>.
Definition: BigMatrix.h:1552
RowVector_< Complex > ComplexRowVector
Variable-size row vector of Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1497
Vector_< float > fVector
Abbreviation for Vector_<float>.
Definition: BigMatrix.h:1514
RowVectorView_< fComplex > fComplexRowVectorView
Abbreviation for RowVectorView_<std::complex<float>>.
Definition: BigMatrix.h:1545
Vector_< Complex > ComplexVector
Variable-size column vector of Complex (std::complex<Real>) elements.
Definition: BigMatrix.h:1493
VectorView_< dComplex > dComplexVectorView
Abbreviation for VectorView_<std::complex<double>>.
Definition: BigMatrix.h:1529
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
void writeUnformatted(std::ostream &o, const T &v)
The default implementation of writeUnformatted<T> converts the object to a String using the templatiz...
Definition: Serialize.h:76
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
Matrix_< typename CNT< E1 >::template Result< E2 >::Sub > operator-(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:584
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
std::ostream & operator<<(std::ostream &o, const ContactForce &f)
Definition: CompliantContactSubsystem.h:387
Matrix_< typename CNT< E1 >::template Result< E2 >::Add > operator+(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:568
ELEM sum(const VectorBase< ELEM > &v)
Definition: VectorMath.h:147
Matrix_< E > operator*(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:605
Definition: MatrixBase.h:128