Simbody 3.7
Loading...
Searching...
No Matches
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"
152
155
156#include <iostream>
157#include <cassert>
158#include <complex>
159#include <cstddef>
160#include <limits>
161
162namespace 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
195namespace SimTK {
196
197// ------------------------ MatrixBase definitions ----------------------------
198
199template <class ELT> inline MatrixView_<ELT>
200MatrixBase<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
210template <class ELT> inline MatrixView_<ELT>
211MatrixBase<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
221template <class E> inline MatrixView_<typename CNT<E>::THerm>
225 helper, typename MatrixHelper<typename CNT<Scalar>::THerm>::TransposeView());
227}
228
229template <class E> inline MatrixView_<typename CNT<E>::THerm>
236
237template <class E> inline VectorView_<E>
243
244template <class E> inline VectorView_<E>
250
251template <class ELT> inline VectorView_<ELT>
252MatrixBase<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
260template <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
269template <class ELT> inline RowVectorView_<ELT>
270MatrixBase<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
278template <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].
289template <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
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];
304}
305
306// M = M * diag(v); v must have ncol() elements
307// That is, M(i) *= v[i]
308template <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
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];
323}
324
325
326// M(i,j) *= r[i]*c[j]; r must have nrow() elements; c must have ncol() elements
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]);
333 return *this;
334}
335
336template <class ELT> template <class ER, class EC> inline void
338 const VectorBase<ER>& r,
339 const VectorBase<EC>& c,
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
351template <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.
360template <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
371template <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
381template <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
389template <class ELT> template <class S> inline void
391 const S& s,
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
402template <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
410template <class ELT> template <class S> inline void
412 const S& s,
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)
423template <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
434template <class ELT> template <class S> inline void
436 const S& s,
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
447template <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
457template <class ELT> template <class EE> inline void
459 const MatrixBase<EE>& r,
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
471template <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
483template <class ELT> template <class EE> inline void
485 const MatrixBase<EE>& r,
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
497template <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
507template <class ELT> template <class EE> inline void
509 const MatrixBase<EE>& r,
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
520template <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
532template <class ELT> template <class EE> inline void
534 const MatrixBase<EE>& r,
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/*
546template <class ELT> inline MatrixView_< typename CNT<ELT>::TReal >
547MatrixBase<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.
566template <class E1, class E2>
569 return Matrix_<typename CNT<E1>::template Result<E2>::Add>(l) += r;
571
572template <class E>
573Matrix_<E> operator+(const MatrixBase<E>& l, const typename CNT<E>::T& r) {
574 return Matrix_<E>(l) += r;
575}
576
577template <class E>
578Matrix_<E> operator+(const typename CNT<E>::T& l, const MatrixBase<E>& r) {
579 return Matrix_<E>(r) += l;
580}
581
582template <class E1, class E2>
583Matrix_<typename CNT<E1>::template Result<E2>::Sub>
585 return Matrix_<typename CNT<E1>::template Result<E2>::Sub>(l) -= r;
586}
588template <class E>
589Matrix_<E> operator-(const MatrixBase<E>& l, const typename CNT<E>::T& r) {
590 return Matrix_<E>(l) -= r;
591}
592
593template <class E>
594Matrix_<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);
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.
604template <class E> Matrix_<E>
605operator*(const MatrixBase<E>& l, const typename CNT<E>::StdNumber& r)
606 { return Matrix_<E>(l)*=r; }
608template <class E> Matrix_<E>
609operator*(const typename CNT<E>::StdNumber& l, const MatrixBase<E>& r)
610 { return Matrix_<E>(r)*=l; }
611
612template <class E> Matrix_<E>
613operator/(const MatrixBase<E>& l, const typename CNT<E>::StdNumber& r)
614 { return Matrix_<E>(l)/=r; }
616// Handle ints explicitly.
617template <class E> Matrix_<E>
618operator*(const MatrixBase<E>& l, int r)
619 { return Matrix_<E>(l)*= typename CNT<E>::StdNumber(r); }
620
621template <class E> Matrix_<E>
622operator*(int l, const MatrixBase<E>& r)
623 { return Matrix_<E>(r)*= typename CNT<E>::StdNumber(l); }
624
625template <class E> Matrix_<E>
626operator/(const MatrixBase<E>& l, int r)
627 { return Matrix_<E>(l)/= typename CNT<E>::StdNumber(r); }
628
630
634
635template <class E1, class E2>
636Vector_<typename CNT<E1>::template Result<E2>::Add>
638 return Vector_<typename CNT<E1>::template Result<E2>::Add>(l) += r;
639}
640template <class E>
641Vector_<E> operator+(const VectorBase<E>& l, const typename CNT<E>::T& r) {
642 return Vector_<E>(l) += r;
643}
644template <class E>
645Vector_<E> operator+(const typename CNT<E>::T& l, const VectorBase<E>& r) {
646 return Vector_<E>(r) += l;
647}
648template <class E1, class E2>
649Vector_<typename CNT<E1>::template Result<E2>::Sub>
651 return Vector_<typename CNT<E1>::template Result<E2>::Sub>(l) -= r;
652}
653template <class E>
654Vector_<E> operator-(const VectorBase<E>& l, const typename CNT<E>::T& r) {
655 return Vector_<E>(l) -= r;
656}
657template <class E>
658Vector_<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
666template <class E> Vector_<E>
667operator*(const VectorBase<E>& l, const typename CNT<E>::StdNumber& r)
668 { return Vector_<E>(l)*=r; }
669
670template <class E> Vector_<E>
671operator*(const typename CNT<E>::StdNumber& l, const VectorBase<E>& r)
672 { return Vector_<E>(r)*=l; }
673
674template <class E> Vector_<E>
675operator/(const VectorBase<E>& l, const typename CNT<E>::StdNumber& r)
676 { return Vector_<E>(l)/=r; }
677
678// Handle ints explicitly
679template <class E> Vector_<E>
680operator*(const VectorBase<E>& l, int r)
681 { return Vector_<E>(l)*= typename CNT<E>::StdNumber(r); }
682
683template <class E> Vector_<E>
684operator*(int l, const VectorBase<E>& r)
685 { return Vector_<E>(r)*= typename CNT<E>::StdNumber(l); }
686
687template <class E> Vector_<E>
688operator/(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
695template <class E1, int M, class E2, int S>
696Vector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul>
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
705template <class E1, int M, class E2, int S>
706Vector_<typename Vec<M,E2,S>::template Result<E1>::Mul>
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
715template <class E1, int N, class E2, int S>
716Vector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul>
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
725template <class E1, int N, class E2, int S>
726Vector_<typename Row<N,E2,S>::template Result<E1>::Mul>
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
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>
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
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>
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
755template <class E1, int M, class E2, int S>
756Vector_<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
765template <class E1, int M, class E2, int S>
766Vector_<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
780template <class E1, class E2>
781RowVector_<typename CNT<E1>::template Result<E2>::Add>
783 return RowVector_<typename CNT<E1>::template Result<E2>::Add>(l) += r;
784}
785template <class E>
786RowVector_<E> operator+(const RowVectorBase<E>& l, const typename CNT<E>::T& r) {
787 return RowVector_<E>(l) += r;
788}
789template <class E>
790RowVector_<E> operator+(const typename CNT<E>::T& l, const RowVectorBase<E>& r) {
791 return RowVector_<E>(r) += l;
792}
793template <class E1, class E2>
794RowVector_<typename CNT<E1>::template Result<E2>::Sub>
796 return RowVector_<typename CNT<E1>::template Result<E2>::Sub>(l) -= r;
797}
798template <class E>
799RowVector_<E> operator-(const RowVectorBase<E>& l, const typename CNT<E>::T& r) {
800 return RowVector_<E>(l) -= r;
801}
802template <class E>
803RowVector_<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
811template <class E> RowVector_<E>
812operator*(const RowVectorBase<E>& l, const typename CNT<E>::StdNumber& r)
813 { return RowVector_<E>(l)*=r; }
814
815template <class E> RowVector_<E>
816operator*(const typename CNT<E>::StdNumber& l, const RowVectorBase<E>& r)
817 { return RowVector_<E>(r)*=l; }
818
819template <class E> RowVector_<E>
820operator/(const RowVectorBase<E>& l, const typename CNT<E>::StdNumber& r)
821 { return RowVector_<E>(l)/=r; }
822
823// Handle ints explicitly.
824template <class E> RowVector_<E>
826 { return RowVector_<E>(l)*= typename CNT<E>::StdNumber(r); }
827
828template <class E> RowVector_<E>
830 { return RowVector_<E>(r)*= typename CNT<E>::StdNumber(l); }
831
832template <class E> RowVector_<E>
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
841template <class E1, int M, class E2, int S>
842RowVector_<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
851template <class E1, int M, class E2, int S>
852RowVector_<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
861template <class E1, int N, class E2, int S>
862RowVector_<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
871template <class E1, int N, class E2, int S>
872RowVector_<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
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>
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
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)
896 res[i] = s*v[i];
897 return res;
898}
899
900// RowVector * SymMat
901template <class E1, int M, class E2, int S>
902RowVector_<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
911template <class E1, int M, class E2, int S>
912RowVector_<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
931template <class E1, class E2>
932typename 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
941template <class E1, class E2>
942Vector_<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
951template <class E1, class E2>
952Matrix_<typename CNT<E1>::template Result<E2>::Mul>
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.
976template <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)
1135 out.resizeKeep(out.size()+1); // grow by one (default consructed)
1136 in >> out[nextIndex]; if (in.fail()) break;
1137 ++nextIndex;
1138
1139 if (!in.good()) break; // might be eof
1140 }
1141
1142 // We will get here under a number of circumstances:
1143 // - the fail bit is set in the istream, or
1144 // - we reached eof
1145 // - we saw a closing brace
1146 // - we got all the elements we wanted (for a fixed-size read)
1147 // Note that it is possible that we consumed everything except some
1148 // trailing white space (meaning we're not technically at eof), but
1149 // for consistency with built-in operator>>()'s we won't try to absorb
1150 // that trailing white space.
1151
1152 if (!in.fail()) {
1153 if (lookForCloser && !terminatorSeen)
1154 in.setstate(std::ios::failbit); // missing terminator
1155
1156 if (isFixedSize && nextIndex != numRequired)
1157 in.setstate(std::ios::failbit); // wrong number of values
1158 }
1159
1160 return in;
1161}
1162
1163
1164
1165//------------------------------------------------------------------------------
1166// RELATED GLOBAL OPERATORS
1167//------------------------------------------------------------------------------
1168// These are logically part of the Matrix_<T> class but are not actually
1169// class members; that is, they are in the SimTK namespace.
1170
1182template <class E> inline void
1183writeUnformatted(std::ostream& o, const VectorBase<E>& v) {
1184 const int sz = v.size();
1185 for (int i=0; i < sz; ++i) {
1186 if (i != 0) o << " ";
1187 writeUnformatted(o, v[i]);
1188 }
1189}
1192template <class E> inline void
1193writeUnformatted(std::ostream& o, const VectorView_<E>& v)
1194{ writeUnformatted(o, static_cast< const VectorBase<E> >(v)); }
1195
1198template <class E> inline void
1199writeUnformatted(std::ostream& o, const Vector_<E>& v)
1200{ writeUnformatted(o, static_cast< const VectorBase<E> >(v)); }
1201
1205template <class E> inline void
1206writeUnformatted(std::ostream& o, const RowVectorBase<E>& v)
1207{ writeUnformatted(o, ~v); }
1208
1211template <class E> inline void
1212writeUnformatted(std::ostream& o, const RowVectorView_<E>& v)
1213{ writeUnformatted(o, static_cast< const RowVectorBase<E> >(v)); }
1214
1217template <class E> inline void
1218writeUnformatted(std::ostream& o, const RowVector_<E>& v)
1219{ writeUnformatted(o, static_cast< const RowVectorBase<E> >(v)); }
1220
1224template <class E> inline void
1225writeUnformatted(std::ostream& o, const MatrixBase<E>& v) {
1226 const int nr = v.nrow();
1227 for (int i=0; i < nr; ++i) {
1228 if (i != 0) o << std::endl;
1229 writeUnformatted(o, v[i]);
1230 }
1231}
1234template <class E> inline void
1235writeUnformatted(std::ostream& o, const MatrixView_<E>& v)
1236{ writeUnformatted(o, static_cast< const MatrixBase<E> >(v)); }
1237
1240template <class E> inline void
1241writeUnformatted(std::ostream& o, const Matrix_<E>& v)
1242{ writeUnformatted(o, static_cast< const MatrixBase<E> >(v)); }
1243
1247template <class E> inline bool
1248readUnformatted(std::istream& in, VectorView_<E>& v) {
1249 for (int i=0; i < v.size(); ++i)
1250 if (!readUnformatted(in, v[i])) return false;
1251 return true;
1252}
1253
1256template <class E> inline bool
1257readUnformatted(std::istream& in, Vector_<E>& v) {
1258 if (!v.isResizeable())
1259 return readUnformatted(in, v.updAsVectorView());
1260
1261 Array_<E,int> a;
1262 if (!readUnformatted(in,a)) return false;
1263 v.resize(a.size());
1264 for (int i=0; i<a.size(); ++i)
1265 v[i] = a[i];
1266 return true;
1267}
1268
1272template <class E> inline bool
1274{ VectorView_<E> vt(~v);
1275 return readUnformatted<E>(in, vt); }
1276
1280template <class E> inline bool
1281readUnformatted(std::istream& in, RowVector_<E>& v)
1282{ Vector_<E> vt(~v);
1283 return readUnformatted<E>(in, vt); }
1284
1290template <class E> inline bool
1291readUnformatted(std::istream& in, MatrixView_<E>& v) {
1292 for (int row=0; row < v.nrow(); ++row) {
1293 RowVectorView_<E> oneRow(v[row]);
1294 if (!readUnformatted<E>(in, oneRow)) return false;
1295 }
1296 return true;
1297}
1298
1304template <class E> inline bool
1305fillUnformatted(std::istream& in, Matrix_<E>& v) {
1306 return readUnformatted<E>(in, v.updAsMatrixView());
1307}
1308
1312template <class E> inline bool
1313readUnformatted(std::istream& in, Matrix_<E>& v) {
1314 SimTK_ASSERT_ALWAYS(!"implemented",
1315 "SimTK::readUnformatted(istream, Matrix) is not implemented; try"
1316 " SimTK::fillUnformatted(istream, Matrix) instead.");
1317 return false;
1318}
1319
1326template <class T> inline std::ostream&
1327operator<<(std::ostream& o, const VectorBase<T>& v)
1328{ o << "~[";
1329 if (v.size()) {
1330 o << v[0];
1331 for (int i=1; i < v.size(); ++i) o << " " << v[i];
1332 }
1333 return o << "]";
1334}
1335
1342template <class T> inline std::ostream&
1343operator<<(std::ostream& o, const RowVectorBase<T>& v)
1344{ o << "[";
1345 if (v.size()) {
1346 o << v[0];
1347 for (int i=1; i < v.size(); ++i) o << " " << v[i];
1348 }
1349 return o << "]";
1350}
1351
1359template <class T> inline std::ostream&
1360operator<<(std::ostream& o, const MatrixBase<T>& m) {
1361 for (int i=0;i<m.nrow();++i)
1362 o << std::endl << m[i];
1363 if (m.nrow()) o << std::endl;
1364 return o;
1365}
1366
1367
1399template <class T> static inline
1400std::istream& readVectorFromStream(std::istream& in, Vector_<T>& out)
1401{ return readVectorFromStreamHelper<T>(in, false /*variable sizez*/, out); }
1402
1403
1404
1429template <class T> static inline
1430std::istream& fillVectorFromStream(std::istream& in, Vector_<T>& out)
1431{ return readVectorFromStreamHelper<T>(in, true /*fixed size*/, out); }
1432
1437template <class T> static inline
1438std::istream& fillVectorViewFromStream(std::istream& in, VectorView_<T>& out)
1439{ return readVectorFromStreamHelper<T>(in, true /*fixed size*/, out); }
1440
1441
1451template <class T> inline
1452std::istream& operator>>(std::istream& in, Vector_<T>& out)
1453{ return readVectorFromStream<T>(in, out); }
1454
1462template <class T> inline
1463std::istream& operator>>(std::istream& in, VectorView_<T>& out)
1464{ return fillVectorViewFromStream<T>(in, out); }
// End of Matrix serialization.
1466
1467// Friendly abbreviations for vectors and matrices with scalar elements.
1474
1479
1494
1501
1508
1517
1526
1535
1544
1553
1564} //namespace SimTK
1565
1566#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
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
Definition MatrixHelper.h:98
Here we define class MatrixHelper, the scalar-type templatized helper class for the more general,...
Definition MatrixHelper.h:79
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
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_< 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