Go to the documentation of this file. 1 #ifndef SimTK_SIMMATRIX_SMALLMATRIX_SYMMAT_H_
2 #define SimTK_SIMMATRIX_SMALLMATRIX_SYMMAT_H_
87 template <
int M,
class ELT,
int RS>
class SymMat {
175 static int size() {
return (M*(M+1))/2; }
176 static int nrow() {
return M; }
177 static int ncol() {
return M; }
221 typedef typename MulOp::Type
Mul;
226 typedef typename MulOpNonConforming::Type
MulNon;
232 typedef typename DvdOp::Type
Dvd;
237 typedef typename AddOp::Type
Add;
242 typedef typename SubOp::Type
Sub;
279 template <
class EE,
int CSS,
int RSS>
286 template <
class EE,
int CSS,
int RSS>
289 for (
int j=0; j<M; ++j)
290 for (
int i=j+1; i<M; ++i)
302 template <
class EE,
int CSS,
int RSS>
305 for (
int j=0; j<M; ++j)
306 for (
int i=j+1; i<M; ++i)
316 template <
class EE,
int CSS,
int RSS>
319 "The allegedly symmetric source matrix was not symmetric to within "
322 for (
int j=0; j<M; ++j)
323 for (
int i=j+1; i<M; ++i)
379 const E& e1,
const E& e2)
385 const E& e1,
const E& e2,
386 const E& e3,
const E& e4,
const E& e5)
393 const E& e1,
const E& e2,
394 const E& e3,
const E& e4,
const E& e5,
395 const E& e6,
const E& e7,
const E& e8,
const E& e9)
398 l[0]=e1;l[1]=e3;l[2]=e6;
403 const E& e1,
const E& e2,
404 const E& e3,
const E& e4,
const E& e5,
405 const E& e6,
const E& e7,
const E& e8,
const E& e9,
406 const E& e10,
const E& e11,
const E& e12,
const E& e13,
const E& e14)
409 l[0]=e1;l[1]=e3;l[2]=e6;l[3]=e10;
410 l[4]=e4;l[5]=e7;l[6]=e11;
415 const E& e1,
const E& e2,
416 const E& e3,
const E& e4,
const E& e5,
417 const E& e6,
const E& e7,
const E& e8,
const E& e9,
418 const E& e10,
const E& e11,
const E& e12,
const E& e13,
const E& e14,
419 const E& e15,
const E& e16,
const E& e17,
const E& e18,
const E& e19,
const E& e20)
423 l[0] =e1; l[1] =e3; l[2] =e6; l[3]=e10; l[4]=e15;
424 l[5] =e4; l[6] =e7; l[7] =e11; l[8]=e16;
425 l[9] =e8; l[10]=e12;l[11]=e17;
443 template <
class EE>
explicit SymMat(
const EE* p) {
445 for (
int i=0; i<M; ++i) {
446 const int rowStart = (i*(i+1))/2;
448 for (
int j=0; j<i; ++j)
457 for (
int i=0; i<M; ++i) {
458 const int rowStart = (i*(i+1))/2;
460 for (
int j=0; j<i; ++j)
476 template <
class EE,
int RSS>
SymMat&
481 template <
class EE,
int RSS>
SymMat&
487 template <
class EE,
int RSS>
SymMat&
492 template <
class EE,
int RSS>
SymMat&
500 template <
class EE,
int RSS>
SymMat&
510 template <
class E2,
int RS2>
511 typename Result<SymMat<M,E2,RS2> >::Add
513 return typename Result<SymMat<M,E2,RS2> >::Add
517 template <
class E2,
int RS2>
518 typename Result<SymMat<M,E2,RS2> >::Sub
520 return typename Result<SymMat<M,E2,RS2> >::Sub
527 template <
class E2,
int RS2>
528 typename Result<SymMat<M,E2,RS2> >::Mul
530 typename Result<SymMat<M,E2,RS2> >::Mul result;
531 for (
int j=0;j<M;++j)
532 for (
int i=0;i<M;++i)
533 result(i,j) = (*this)[i] * s(j);
538 template <
class E2,
int RS2>
546 template <
class E2,
int RS2>
590 return elementwiseNormalized;
609 {
return *
reinterpret_cast<const TPosTrans*
>(
this); }
611 {
return *
reinterpret_cast<TPosTrans*
>(
this); }
619 const EImag* p =
reinterpret_cast<const EImag*
>(
this);
620 return *
reinterpret_cast<const TImag*
>(p+offs);
624 EImag* p =
reinterpret_cast<EImag*
>(
this);
625 return *
reinterpret_cast<TImag*
>(p+offs);
670 result.updDiag() += e;
704 {
updDiag() += ee;
return *
this; }
706 {
updDiag() -= ee;
return *
this; }
750 template <
class E2,
int RS2>
758 template <
class E2,
int RS2>
785 for (
int j=0; j<i; ++j)
788 for (
int j=i+1; j<M; ++j)
797 for (
int i=0; i<j; ++i)
800 for (
int i=j+1; i<M; ++i)
810 E
elt(
int i,
int j)
const {
848 for (
int i = 1; i < M; ++i)
849 for (
int j = 0; j < i; ++j) {
852 temp[i] += E(
reinterpret_cast<const EHerm&
>(value));
864 for (
int i = 1; i < M; ++i)
865 for (
int j = 0; j < i; ++j) {
868 temp[j] += E(
reinterpret_cast<const EHerm&
>(value));
877 const E& getlowerE(
int i)
const {
return d[(M+i)*RS];}
878 E& updlowerE(
int i) {
return d[(M+i)*RS];}
890 static int lowerIx(
int i,
int j) {
891 assert(0 <= j && j < i && i < M);
892 return (i-j-1) + j*(M-1) - (j*(j-1))/2;
895 template <
int MM,
class EE,
int RSS>
friend class SymMat;
904 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline
908 ::AddOp::perform(l,r);
912 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline
913 typename SymMat<M,E1,S1>::template Result< SymMat<M,E2,S2> >::Sub
916 ::SubOp::perform(l,r);
921 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline
922 typename SymMat<M,E1,S1>::template Result< SymMat<M,E2,S2> >::Mul
925 ::MulOp::perform(l,r);
929 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
931 return l.getAsVec() == r.getAsVec();
935 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
945 template <
int M,
class E,
int S>
inline
946 typename SymMat<M,E,S>::template Result<float>::Mul
949 template <
int M,
class E,
int S>
inline
950 typename SymMat<M,E,S>::template Result<float>::Mul
953 template <
int M,
class E,
int S>
inline
954 typename SymMat<M,E,S>::template Result<double>::Mul
957 template <
int M,
class E,
int S>
inline
958 typename SymMat<M,E,S>::template Result<double>::Mul
962 template <
int M,
class E,
int S>
inline
963 typename SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Mul
965 template <
int M,
class E,
int S>
inline
966 typename SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Mul
972 template <
int M,
class E,
int S,
class R>
inline
973 typename SymMat<M,E,S>::template Result<std::complex<R> >::Mul
976 template <
int M,
class E,
int S,
class R>
inline
977 typename SymMat<M,E,S>::template Result<std::complex<R> >::Mul
981 template <
int M,
class E,
int S,
class R>
inline
982 typename SymMat<M,E,S>::template Result<std::complex<R> >::Mul
984 template <
int M,
class E,
int S,
class R>
inline
985 typename SymMat<M,E,S>::template Result<std::complex<R> >::Mul
989 template <
int M,
class E,
int S,
class R>
inline
990 typename SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul
992 template <
int M,
class E,
int S,
class R>
inline
993 typename SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul
1002 template <
int M,
class E,
int S>
inline
1003 typename SymMat<M,E,S>::template Result<float>::Dvd
1006 template <
int M,
class E,
int S>
inline
1007 typename CNT<float>::template Result<SymMat<M,E,S> >::Dvd
1011 template <
int M,
class E,
int S>
inline
1012 typename SymMat<M,E,S>::template Result<double>::Dvd
1015 template <
int M,
class E,
int S>
inline
1016 typename CNT<double>::template Result<SymMat<M,E,S> >::Dvd
1021 template <
int M,
class E,
int S>
inline
1022 typename SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Dvd
1024 template <
int M,
class E,
int S>
inline
1032 template <
int M,
class E,
int S,
class R>
inline
1033 typename SymMat<M,E,S>::template Result<std::complex<R> >::Dvd
1036 template <
int M,
class E,
int S,
class R>
inline
1037 typename CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Dvd
1042 template <
int M,
class E,
int S,
class R>
inline
1043 typename SymMat<M,E,S>::template Result<std::complex<R> >::Dvd
1045 template <
int M,
class E,
int S,
class R>
inline
1046 typename CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Dvd
1050 template <
int M,
class E,
int S,
class R>
inline
1051 typename SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Dvd
1053 template <
int M,
class E,
int S,
class R>
inline
1054 typename CNT<R>::template Result<SymMat<M,E,S> >::Dvd
1065 template <
int M,
class E,
int S>
inline
1066 typename SymMat<M,E,S>::template Result<float>::Add
1069 template <
int M,
class E,
int S>
inline
1070 typename SymMat<M,E,S>::template Result<float>::Add
1073 template <
int M,
class E,
int S>
inline
1074 typename SymMat<M,E,S>::template Result<double>::Add
1077 template <
int M,
class E,
int S>
inline
1078 typename SymMat<M,E,S>::template Result<double>::Add
1082 template <
int M,
class E,
int S>
inline
1083 typename SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Add
1085 template <
int M,
class E,
int S>
inline
1086 typename SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Add
1092 template <
int M,
class E,
int S,
class R>
inline
1093 typename SymMat<M,E,S>::template Result<std::complex<R> >::Add
1096 template <
int M,
class E,
int S,
class R>
inline
1097 typename SymMat<M,E,S>::template Result<std::complex<R> >::Add
1101 template <
int M,
class E,
int S,
class R>
inline
1102 typename SymMat<M,E,S>::template Result<std::complex<R> >::Add
1104 template <
int M,
class E,
int S,
class R>
inline
1105 typename SymMat<M,E,S>::template Result<std::complex<R> >::Add
1109 template <
int M,
class E,
int S,
class R>
inline
1110 typename SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Add
1112 template <
int M,
class E,
int S,
class R>
inline
1113 typename SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Add
1119 template <
int M,
class E,
int S>
inline
1120 typename SymMat<M,E,S>::template Result<float>::Sub
1123 template <
int M,
class E,
int S>
inline
1124 typename CNT<float>::template Result<SymMat<M,E,S> >::Sub
1128 template <
int M,
class E,
int S>
inline
1129 typename SymMat<M,E,S>::template Result<double>::Sub
1132 template <
int M,
class E,
int S>
inline
1133 typename CNT<double>::template Result<SymMat<M,E,S> >::Sub
1138 template <
int M,
class E,
int S>
inline
1139 typename SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Sub
1141 template <
int M,
class E,
int S>
inline
1149 template <
int M,
class E,
int S,
class R>
inline
1150 typename SymMat<M,E,S>::template Result<std::complex<R> >::Sub
1153 template <
int M,
class E,
int S,
class R>
inline
1154 typename CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Sub
1159 template <
int M,
class E,
int S,
class R>
inline
1160 typename SymMat<M,E,S>::template Result<std::complex<R> >::Sub
1162 template <
int M,
class E,
int S,
class R>
inline
1163 typename CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Sub
1167 template <
int M,
class E,
int S,
class R>
inline
1168 typename SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Sub
1170 template <
int M,
class E,
int S,
class R>
inline
1171 typename CNT<R>::template Result<SymMat<M,E,S> >::Sub
1176 template <
int M,
class E,
int RS,
class CHAR,
class TRAITS>
inline
1177 std::basic_ostream<CHAR,TRAITS>&
1179 for (
int i=0;i<M;++i) {
1180 o << std::endl <<
"[";
1181 for (
int j=0; j<=i; ++j)
1182 o << (j>0?
" ":
"") << m(i,j);
1183 for (
int j=i+1; j<M; ++j)
1187 if (M) o << std::endl;
1191 template <
int M,
class E,
int RS,
class CHAR,
class TRAITS>
inline
1192 std::basic_istream<CHAR,TRAITS>&
1202 #endif //SimTK_SIMMATRIX_SMALLMATRIX_SYMMAT_H_
E TElement
Definition: SymMat.h:149
TCol col(int j) const
Definition: SymMat.h:793
static Vec & updAs(ELT *p)
Recast a writable ordinary C++ array E[] to a writable Vec<M,E,S>; assumes compatible length,...
Definition: Vec.h:908
bool isNumericallyEqual(const SymMat< M, E2, RS2 > &m, double tol) const
Test whether this matrix is numerically equal to some other matrix with the same shape,...
Definition: SymMat.h:751
MulOp::Type Mul
Definition: SymMat.h:221
AddCNTs< M, M, ArgDepth, SymMat, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > AddOp
Definition: SymMat.h:236
SymMat< M, EReal, RS *CNT< E >::RealStrideFactor > TReal
Definition: SymMat.h:143
EltResult< E2 >::Dvd elementwiseDivide(const SymMat< M, E2, RS2 > &r) const
Definition: SymMat.h:548
static double getDefaultTolerance()
For approximate comparisons, the default tolerance to use for a matrix is its shortest dimension time...
Definition: SymMat.h:746
SymMat(const Mat< M, M, EE, CSS, RSS > &m)
This is an explicit conversion from square Mat of right size, assuming that the source matrix is symm...
Definition: SymMat.h:280
@ NPackedElements
Definition: SymMat.h:119
const TAsVec & getAsVec() const
Definition: SymMat.h:831
SimTK::conjugate<R> should be instantiated only for float, double.
Definition: String.h:45
This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:621
friend class SymMat
Definition: SymMat.h:895
TNormalize normalize() const
If the elements of this Vec are scalars, the result is what you get by dividing each element by the n...
Definition: Vec.h:623
void setToNaN()
Set every scalar in this Vec to NaN; this is the default initial value in Debug builds,...
Definition: Vec.h:812
EScalarNormSq ScalarNormSq
Definition: SymMat.h:173
SymMat< M, typename CNT< E >::template Result< EE >::Add > scalarAdd(const EE &e) const
Definition: SymMat.h:668
static int nrow()
Definition: SymMat.h:176
static TSqrt sqrt(const K &t)
Definition: CompositeNumericalTypes.h:239
const TImag & imag() const
Definition: SymMat.h:617
const E & getEltLower(int i, int j) const
Definition: SymMat.h:838
K::Number Number
Definition: CompositeNumericalTypes.h:162
TImag & imag()
Definition: SymMat.h:622
SymMat & scalarMinusEq(const EE &ee)
Definition: SymMat.h:705
K::TSqHermT TSqHermT
Definition: CompositeNumericalTypes.h:146
TUpper & updUpper()
Definition: SymMat.h:829
EStdNumber StdNumber
Definition: SymMat.h:171
Row< M, E, 1 > TRow
Definition: SymMat.h:157
bool isFinite() const
Return true if no element of this Vec contains an Infinity or a NaN anywhere.
Definition: Vec.h:942
static int size()
Definition: SymMat.h:175
SymMat< M, typename CNT< EE >::template Result< E >::Mul > scalarMultiplyFromLeft(const EE &e) const
Definition: SymMat.h:645
Result< SymMat< M, E2, RS2 > >::Add conformingAdd(const SymMat< M, E2, RS2 > &r) const
Definition: SymMat.h:512
SymMat & operator/=(const EE &e)
Definition: SymMat.h:697
TReal & real()
Definition: SymMat.h:614
TRow colSum() const
Returns a row vector (Row) containing the column sums of this matrix.
Definition: SymMat.h:846
THerm & updTranspose()
Definition: SymMat.h:606
const TReal & real() const
Definition: SymMat.h:613
Vec & scalarDivideEqFromLeft(const EE &ee)
Definition: Vec.h:797
SymMat< M, ESqrt, 1 > TSqrt
Definition: SymMat.h:159
@ IsStdNumber
Definition: SymMat.h:133
@ NCols
Definition: SymMat.h:116
SymMat & operator*=(const SymMat< M, EE, RSS > &mm)
Definition: SymMat.h:501
SymMat< M, P > Type
Definition: SymMat.h:247
const TReal & real() const
Return a reference to the real portion of this Vec if it has complex elements; otherwise the type doe...
Definition: Vec.h:681
SymMat(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9)
Definition: SymMat.h:392
SymMat & scalarPlusEq(const EE &ee)
Definition: SymMat.h:703
SymMat< M, EComplex, RS > TComplex
Definition: SymMat.h:146
MulCNTs< M, M, ArgDepth, SymMat, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > MulOp
Definition: SymMat.h:220
K::TImag TImag
Definition: CompositeNumericalTypes.h:142
Vec<(M *(M+1))/2, E, RS > TAsVec
Definition: SymMat.h:153
K::TSqTHerm TSqTHerm
Definition: CompositeNumericalTypes.h:147
K::ULessScalar ULessScalar
Definition: CompositeNumericalTypes.h:161
EltResult< E2 >::Mul elementwiseMultiply(const SymMat< M, E2, RS2 > &r) const
Definition: SymMat.h:540
SymMat< M, EAbs, 1 > TAbs
Definition: SymMat.h:160
SymMat(int i)
Definition: SymMat.h:361
@ ImagOffset
Definition: SymMat.h:124
SymMat(const SymMat< M, ENeg, RSS > &src)
This is an implicit conversion from a SymMat of the same length and negated element type,...
Definition: SymMat.h:336
SymMat< M, E, 1 > TPacked
Definition: SymMat.h:166
TWithoutNegator & updCastAwayNegatorIfAny()
Definition: SymMat.h:629
TDiag & updDiag()
Definition: SymMat.h:819
THerm & operator~()
Definition: SymMat.h:600
Vec< M, E, RS > TDiag
Definition: SymMat.h:150
EStandard trace() const
Definition: SymMat.h:203
TStandard standardize() const
Definition: SymMat.h:199
CNT< ScalarNormSq >::TSqrt norm() const
Definition: SymMat.h:570
@ RowSpacing
Definition: SymMat.h:122
SymMat & scalarDivideEqFromLeft(const EE &ee)
Definition: SymMat.h:718
#define SimTK_ERRCHK1(cond, whereChecked, fmt, a1)
Definition: ExceptionMacros.h:326
Vec & scalarMinusEqFromLeft(const EE &ee)
Definition: Vec.h:789
SymMat & scalarEq(const EE &ee)
Definition: SymMat.h:701
This is a System that represents the dynamics of a particle moving along a smooth surface.
Definition: Assembler.h:37
SymMat(const SymMat< M, E, RSS > &src)
This is an implicit conversion from a SymMat of the same length and element type but with different s...
Definition: SymMat.h:331
static const Vec & getAs(const ELT *p)
Recast an ordinary C++ array E[] to a const Vec<M,E,S>; assumes compatible length,...
Definition: Vec.h:904
static const SymMat & getAs(const ELT *p)
Definition: SymMat.h:725
K::TInvert TInvert
Definition: CompositeNumericalTypes.h:157
@ IsScalar
Definition: SymMat.h:130
const TLower & getLower() const
Definition: SymMat.h:825
SymMat< M, ENormalize, 1 > TNormalize
Definition: SymMat.h:163
SymMat & operator=(const SymMat< M, EE, RSS > &mm)
Definition: SymMat.h:469
@ MAX_RESOLVED_DEPTH
Definition: CompositeNumericalTypes.h:120
SymMat< M, typename CNT< EE >::template Result< E >::Sub > scalarSubtractFromLeft(const EE &e) const
Definition: SymMat.h:684
@ SignInterpretation
Definition: SymMat.h:135
SymMat & scalarDivideEq(const EE &ee)
Definition: SymMat.h:716
static const THerm & transpose(const K &t)
Definition: CompositeNumericalTypes.h:216
SymMat & scalarTimesEq(const EE &ee)
Definition: SymMat.h:712
SymMat & operator+=(const SymMat< M, negator< EE >, RSS > &mm)
Definition: SymMat.h:482
void setToZero()
Set every scalar in this Vec to zero.
Definition: Vec.h:817
SymMat & operator=(const SymMat &src)
Copy assignment; no harm if source and this are the same matrix.
Definition: SymMat.h:264
SymMat(const SymMat &src)
Copy constructor.
Definition: SymMat.h:259
TAbs abs() const
Definition: SymMat.h:195
TRow row(int i) const
Definition: SymMat.h:781
K::ScalarNormSq ScalarNormSq
Definition: CompositeNumericalTypes.h:166
K::Precision Precision
Definition: CompositeNumericalTypes.h:164
SymMat< M, typename CNT< E >::template Result< EE >::Sub > scalarSubtract(const EE &e) const
Definition: SymMat.h:676
TRow operator[](int i) const
Definition: SymMat.h:563
EULessScalar ULessScalar
Definition: SymMat.h:169
SymMat(const E &e)
Definition: SymMat.h:347
SymMat< M, EImag, RS *CNT< E >::RealStrideFactor > TImag
Definition: SymMat.h:145
std::basic_istream< CHAR, TRAITS > & operator>>(std::basic_istream< CHAR, TRAITS > &is, conjugate< R > &c)
Definition: conjugate.h:505
SymMat(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)
Definition: SymMat.h:384
TDiag & diag()
Definition: SymMat.h:823
SubOp::Type Sub
Definition: SymMat.h:242
SymMat & scalarTimesEqFromLeft(const EE &ee)
Definition: SymMat.h:714
SymMat & setFromUpper(const Mat< M, M, EE, CSS, RSS > &m)
Create a new SymMat of this type from a square Mat of the right size, looking only at upper elements ...
Definition: SymMat.h:303
K::Scalar Scalar
Definition: CompositeNumericalTypes.h:160
DvdCNTs< M, M, ArgDepth, SymMat, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > DvdOp
Definition: SymMat.h:231
This is a fixed-length row vector designed for no-overhead inline computation.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:619
TNeg & operator-()
Definition: SymMat.h:598
TNormalize normalize() const
There is no conventional meaning for normalize() applied to a matrix.
Definition: SymMat.h:583
Vec< M, E, 1 > TCol
Definition: SymMat.h:158
SymMat & setFromSymmetric(const Mat< M, M, EE, CSS, RSS > &m)
Create a new SymMat of this type from a square Mat of the right size, that is expected to be symmetri...
Definition: SymMat.h:317
Vec<(M *(M-1))/2, EHerm, RS > TUpper
Definition: SymMat.h:152
@ NActualElements
Definition: SymMat.h:120
This is a fixed-length column vector designed for no-overhead inline computation.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:618
E & updEltLower(int i, int j)
Definition: SymMat.h:839
SymMat< M, typename CNT< E >::template Result< P >::Sub, 1 > Sub
Definition: SymMat.h:212
SymMat & operator*=(const EE &e)
Definition: SymMat.h:696
SymMat< M, typename CNT< EE >::template Result< E >::Dvd > scalarDivideFromLeft(const EE &e) const
Definition: SymMat.h:660
T THerm
Definition: SymMat.h:147
SymMat< M, EInvert, 1 > TInvert
Definition: SymMat.h:162
EPrecision Precision
Definition: SymMat.h:172
SymMat< M, typename CNT< E >::template Result< P >::Add, 1 > Add
Definition: SymMat.h:211
SymMat & operator-=(const EE &e)
Definition: SymMat.h:695
bool isFinite() const
Return true if no element contains an Infinity or a NaN.
Definition: SymMat.h:742
SymMat< M, E, RS > T
Definition: SymMat.h:138
const EHerm & getEltUpper(int i, int j) const
Definition: SymMat.h:842
E & updEltDiag(int i)
Definition: SymMat.h:835
const TDiag & getDiag() const
Definition: SymMat.h:818
Vec< M, typename CNT< E >::template Result< EE >::Mul > scalarMultiply(const EE &e) const
Definition: Vec.h:724
ENumber Number
Definition: SymMat.h:170
TInvert invert() const
Definition: SymMat.h:594
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
const TWithoutNegator & castAwayNegatorIfAny() const
Definition: SymMat.h:628
#define SimTK_INDEXCHECK(ix, ub, where)
Definition: ExceptionMacros.h:145
K::TNormalize TNormalize
Definition: CompositeNumericalTypes.h:158
static double getDefaultTolerance()
Definition: CompositeNumericalTypes.h:269
SymMat< M, typename CNT< E >::template Result< P >::Mul, 1 > Mul
Definition: SymMat.h:209
EStandard sum() const
Sum just adds up all the elements into a single return element that is the same type as this Vec's el...
Definition: Vec.h:366
SymMat< M, typename CNT< E >::template Result< EE >::Dvd > scalarDivide(const EE &e) const
Definition: SymMat.h:654
SymMat & setFromLower(const Mat< M, M, EE, CSS, RSS > &m)
Create a new SymMat of this type from a square Mat of the right size, looking only at lower elements ...
Definition: SymMat.h:287
const TNeg & negate() const
Definition: SymMat.h:602
K::TPosTrans TPosTrans
Definition: CompositeNumericalTypes.h:145
MulCNTsNonConforming< M, M, ArgDepth, SymMat, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > MulOpNonConforming
Definition: SymMat.h:225
K::StdNumber StdNumber
Definition: CompositeNumericalTypes.h:163
const E & operator()(int i, int j) const
Definition: SymMat.h:556
@ NActualScalars
Definition: SymMat.h:121
const SymMat & operator+() const
Definition: SymMat.h:596
static TPacked getNaN()
Definition: SymMat.h:729
Result< SymMat< M, E2, RS2 > >::Sub conformingSubtract(const SymMat< M, E2, RS2 > &r) const
Definition: SymMat.h:519
ScalarNormSq scalarNormSqr() const
Definition: SymMat.h:181
SymMat< M, EStandard, 1 > TStandard
Definition: SymMat.h:161
SymMat(const SymMat< M, EE, RSS > &src)
Construct a SymMat from a SymMat of the same dimensions, with any element type and spacing.
Definition: SymMat.h:342
Matrix_< E > operator*(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:605
void setToNaN()
Definition: SymMat.h:721
E elt(int i, int j) const
Return a value for any element of a symmetric matrix, even those in the upper triangle which aren't a...
Definition: SymMat.h:810
const TUpper & getUpper() const
Definition: SymMat.h:828
Matrix_< typename CNT< E1 >::template Result< E2 >::Sub > operator-(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:584
SymMat & operator-=(const SymMat< M, EE, RSS > &mm)
Definition: SymMat.h:488
const E & getEltDiag(int i) const
Definition: SymMat.h:834
@ IsULessScalar
Definition: SymMat.h:131
Vec<(M *(M-1))/2, E, RS > TLower
Definition: SymMat.h:151
@ RealStrideFactor
Definition: SymMat.h:125
Specialized information about Composite Numerical Types which allows us to define appropriate templat...
Definition: CompositeNumericalTypes.h:136
K::TComplex TComplex
Definition: CompositeNumericalTypes.h:143
const TNeg & operator-() const
Definition: SymMat.h:597
bool isNaN() const
Return true if any element of this SymMat contains a NaN anywhere.
Definition: SymMat.h:735
Matrix_< typename CNT< E1 >::template Result< E2 >::Add > operator+(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:568
static SymMat & updAs(ELT *p)
Definition: SymMat.h:726
static int ncol()
Definition: SymMat.h:177
SymMat()
Default construction initializes to NaN when debugging but is left uninitialized otherwise.
Definition: SymMat.h:252
SymMat(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13, const E &e14)
Definition: SymMat.h:402
E & operator()(int i, int j)
Definition: SymMat.h:558
bool operator!=(const L &left, const R &right)
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:641
const TPosTrans & positionalTranspose() const
Definition: SymMat.h:608
SubCNTs< M, M, ArgDepth, SymMat, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > SubOp
Definition: SymMat.h:241
TPosTrans & updPositionalTranspose()
Definition: SymMat.h:610
K::THerm THerm
Definition: CompositeNumericalTypes.h:144
TCol rowSum() const
Returns a column vector (Vec) containing the row sums of this matrix.
Definition: SymMat.h:862
bool isNumericallySymmetric(double tol=getDefaultTolerance()) const
A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian tr...
Definition: Mat.h:1174
const TDiag & diag() const
Select main diagonal (of largest leading square if rectangular) and return it as a read-only view (as...
Definition: Mat.h:800
bool isInf() const
Return true if any element of this Vec contains a +Infinity or -Infinity somewhere but no element con...
Definition: Vec.h:927
const THerm & operator~() const
Definition: SymMat.h:599
@ NLowerElements
Definition: SymMat.h:118
bool isNumericallyEqual(const SymMat< M, E2, RS2 > &m) const
Test whether this matrix is numerically equal to some other matrix with the same shape,...
Definition: SymMat.h:759
@ ArgDepth
Definition: SymMat.h:127
SymMat< M, ESqTHerm, 1 > TSqTHerm
Definition: SymMat.h:165
K::TAbs TAbs
Definition: CompositeNumericalTypes.h:155
Vec< M, typename CNT< EE >::template Result< E >::Mul > scalarMultiplyFromLeft(const EE &e) const
Definition: Vec.h:730
SymMat< M, typename CNT< E >::template Result< EE >::Mul > scalarMultiply(const EE &e) const
Definition: SymMat.h:639
EScalar Scalar
Definition: SymMat.h:168
@ IsPrecision
Definition: SymMat.h:134
SymMat & operator-=(const SymMat< M, negator< EE >, RSS > &mm)
Definition: SymMat.h:493
ScalarNormSq scalarNormSqr() const
Scalar norm square is sum( conjugate squares of all underlying scalars ), where conjugate square of s...
Definition: Vec.h:327
Result< SymMat< M, E2, RS2 > >::Mul conformingMultiply(const SymMat< M, E2, RS2 > &s) const
Definition: SymMat.h:529
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:620
SymMat & operator+=(const SymMat< M, EE, RSS > &mm)
Definition: SymMat.h:477
AddOp::Type Add
Definition: SymMat.h:237
static const TReal & real(const T &t)
Definition: CompositeNumericalTypes.h:203
SymMat & scalarMinusEqFromLeft(const EE &ee)
Definition: SymMat.h:709
SymMat< M, ESqHermT, 1 > TSqHermT
Definition: SymMat.h:164
NTraits< N >::StdNumber StdNumber
Definition: negator.h:107
MulOpNonConforming::Type MulNon
Definition: SymMat.h:226
Vec & scalarTimesEqFromLeft(const EE &ee)
Definition: Vec.h:793
const THerm & transpose() const
Definition: SymMat.h:605
bool isInf() const
Return true if any element of this SymMat contains a +Inf or -Inf somewhere but no element contains a...
Definition: SymMat.h:739
TNeg & updNegate()
Definition: SymMat.h:603
SymMat(const ENeg &e)
Definition: SymMat.h:354
ScalarNormSq normSqr() const
Definition: SymMat.h:568
negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically...
Definition: String.h:44
SymMat(const EE *p)
Definition: SymMat.h:443
@ IsNumber
Definition: SymMat.h:132
const TDiag & diag() const
Definition: SymMat.h:822
Vec< M, typename CNT< E >::template Result< EE >::Dvd > scalarDivide(const EE &e) const
Definition: Vec.h:739
static double getDefaultTolerance()
For approximate comparisons, the default tolerance to use for a matrix is its shortest dimension time...
Definition: Mat.h:1123
SymMat & operator+=(const EE &e)
Definition: SymMat.h:694
bool isNumericallyEqual(const Vec< M, E2, RS2 > &v, double tol) const
Test whether this vector is numerically equal to some other vector with the same shape,...
Definition: Vec.h:956
K::TStandard TStandard
Definition: CompositeNumericalTypes.h:156
@ NRows
Definition: SymMat.h:115
TSqrt sqrt() const
Definition: SymMat.h:188
SymMat< M, ENeg, RS > TNeg
Definition: SymMat.h:139
Vec< M, typename CNT< EE >::template Result< E >::Dvd > scalarDivideFromLeft(const EE &e) const
Definition: Vec.h:745
SymMat< M, typename CNT< E >::template Result< P >::Dvd, 1 > Dvd
Definition: SymMat.h:210
std::ostream & operator<<(std::ostream &o, const ContactForce &f)
Definition: CompliantContactSubsystem.h:387
SymMat< M, EHerm, RS > TPosTrans
Definition: SymMat.h:148
@ ColSpacing
Definition: SymMat.h:123
TCol operator()(int j) const
Definition: SymMat.h:564
K::TSqrt TSqrt
Definition: CompositeNumericalTypes.h:154
SymMat(const E &e0, const E &e1, const E &e2)
A bevy of constructors from individual exact-match elements IN ROW ORDER, giving the LOWER TRIANGLE,...
Definition: SymMat.h:378
bool operator==(const PhiMatrix &p1, const PhiMatrix &p2)
Definition: SpatialAlgebra.h:791
SymMat(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13, const E &e14, const E &e15, const E &e16, const E &e17, const E &e18, const E &e19, const E &e20)
Definition: SymMat.h:414
TAsVec & updAsVec()
Definition: SymMat.h:832
K::TReal TReal
Definition: CompositeNumericalTypes.h:141
TLower & updLower()
Definition: SymMat.h:826
K::TWithoutNegator TWithoutNegator
Definition: CompositeNumericalTypes.h:140
@ NDiagElements
Definition: SymMat.h:117
EHerm & updEltUpper(int i, int j)
Definition: SymMat.h:843
K::TNeg TNeg
Definition: CompositeNumericalTypes.h:139
SymMat & operator=(const EE *p)
Definition: SymMat.h:455
Matrix_< E > operator/(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:613
bool isNaN() const
Return true if any element of this Vec contains a NaN anywhere.
Definition: Vec.h:918
TRow sum() const
This is an alternate name for colSum(); behaves like the Matlab function of the same name.
Definition: SymMat.h:858
void setToZero()
Definition: SymMat.h:722
SymMat< M, EWithoutNegator, RS > TWithoutNegator
Definition: SymMat.h:140
DvdOp::Type Dvd
Definition: SymMat.h:232