1#ifndef SimTK_SIMMATRIX_SMALLMATRIX_VEC_H_
2#define SimTK_SIMMATRIX_SMALLMATRIX_VEC_H_
46template <
class E1,
int S1,
class E2,
int S2>
void
48 Vec<1,
typename CNT<E1>::template Result<E2>::Add>& result) {
49 result[0] = r1[0] + r2[0];
51template <
int N,
class E1,
int S1,
class E2,
int S2>
void
53 Vec<N,
typename CNT<E1>::template Result<E2>::Add>& result) {
55 reinterpret_cast<const Vec<N-1,E2,S2
>&>(r2),
56 reinterpret_cast<Vec<N-1,typename CNT<E1>::
57 template Result<E2>::Add
>&>(result));
58 result[N-1] = r1[N-1] + r2[N-1];
61template <
class E1,
int S1,
class E2,
int S2>
void
63 Vec<1,
typename CNT<E1>::template Result<E2>::Sub>& result) {
64 result[0] = r1[0] - r2[0];
66template <
int N,
class E1,
int S1,
class E2,
int S2>
void
68 Vec<N,
typename CNT<E1>::template Result<E2>::Sub>& result) {
70 reinterpret_cast<const Vec<N-1,E2,S2
>&>(r2),
71 reinterpret_cast<Vec<N-1,typename CNT<E1>::
72 template Result<E2>::Sub
>&>(result));
73 result[N-1] = r1[N-1] - r2[N-1];
76template <
class E1,
int S1,
class E2,
int S2>
void
78 Vec<1,
typename CNT<E1>::template Result<E2>::Mul>& result) {
79 result[0] = r1[0] * r2[0];
81template <
int N,
class E1,
int S1,
class E2,
int S2>
void
83 Vec<N,
typename CNT<E1>::template Result<E2>::Mul>& result) {
85 reinterpret_cast<const Vec<N-1,E2,S2
>&>(r2),
86 reinterpret_cast<Vec<N-1,typename CNT<E1>::
87 template Result<E2>::Mul
>&>(result));
88 result[N-1] = r1[N-1] * r2[N-1];
91template <
class E1,
int S1,
class E2,
int S2>
void
93 Vec<1,
typename CNT<E1>::template Result<E2>::Dvd>& result) {
94 result[0] = r1[0] / r2[0];
96template <
int N,
class E1,
int S1,
class E2,
int S2>
void
98 Vec<N,
typename CNT<E1>::template Result<E2>::Dvd>& result) {
100 reinterpret_cast<const Vec<N-1,E2,S2
>&>(r2),
101 reinterpret_cast<Vec<N-1,typename CNT<E1>::
102 template Result<E2>::Dvd
>&>(result));
103 result[N-1] = r1[N-1] / r2[N-1];
106template <
class E1,
int S1,
class E2,
int S2>
void
107copy(Vec<1,E1,S1>& r1,
const Vec<1,E2,S2>& r2) {
110template <
int N,
class E1,
int S1,
class E2,
int S2>
void
111copy(Vec<N,E1,S1>& r1,
const Vec<N,E2,S2>& r2) {
112 copy(
reinterpret_cast<Vec<N-1,E1,S1
>&>(r1),
113 reinterpret_cast<const Vec<N-1,E2,S2
>&>(r2));
183template <
int M,
class ELT,
int STRIDE>
318 static int size() {
return M; }
320 static int nrow() {
return M; }
322 static int ncol() {
return 1; }
390 typedef typename MulOp::Type
Mul;
395 typedef typename MulOpNonConforming::Type
MulNon;
400 typedef typename DvdOp::Type
Dvd;
405 typedef typename AddOp::Type
Add;
410 typedef typename SubOp::Type
Sub;
493 {
assert(M==3);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2; }
495 {
assert(M==4);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2;(*this)[3]=
e3; }
497 {
assert(M==5);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2;
498 (*this)[3]=
e3;(*this)[4]=
e4; }
500 {
assert(M==6);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2;
501 (*this)[3]=
e3;(*this)[4]=
e4;(*this)[5]=
e5; }
503 {
assert(M==7);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2;
504 (*this)[3]=
e3;(*this)[4]=
e4;(*this)[5]=
e5;(*this)[6]=
e6; }
506 {
assert(M==8);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2;
507 (*this)[3]=
e3;(*this)[4]=
e4;(*this)[5]=
e5;(*this)[6]=
e6;(*this)[7]=
e7; }
509 {
assert(M==9);(*this)[0]=
e0;(*this)[1]=
e1;(*this)[2]=
e2;
510 (*this)[3]=
e3;(*this)[4]=
e4;(*this)[5]=
e5;(*this)[6]=
e6;(*this)[7]=
e7;(*this)[8]=
e8; }
516 template <
class EE>
explicit Vec(
const EE* p)
534 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] +=
r[
i];
return *
this; }
539 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] -= -(
r[
i]);
return *
this; }
544 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] -=
r[
i];
return *
this; }
549 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] += -(
r[
i]);
return *
this; }
628 for (
int i=0;
i<M; ++
i)
672 {
return *
reinterpret_cast<const TPosTrans*
>(
this); }
675 {
return *
reinterpret_cast<TPosTrans*
>(
this); }
694 const EImag* p =
reinterpret_cast<const EImag*
>(
this);
695 return *
reinterpret_cast<const TImag*
>(p+
offs);
702 return *
reinterpret_cast<TImag*
>(p+
offs);
726 for (
int i=0;
i<M; ++
i) result[
i] = (*
this)[
i] * e;
732 for (
int i=0;
i<M; ++
i) result[
i] = e * (*
this)[
i];
741 for (
int i=0;
i<M; ++
i) result[
i] = (*
this)[
i] / e;
747 for (
int i=0;
i<M; ++
i) result[
i] = e / (*
this)[
i];
754 for (
int i=0;
i<M; ++
i) result[
i] = (*
this)[
i] + e;
762 for (
int i=0;
i<M; ++
i) result[
i] = (*
this)[
i] - e;
768 for (
int i=0;
i<M; ++
i) result[
i] = e - (*
this)[
i];
784 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] =
ee;
return *
this; }
786 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] +=
ee;
return *
this; }
788 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] -=
ee;
return *
this; }
792 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] *=
ee;
return *
this; }
796 {
for(
int i=0;
i<M;++
i) d[
i*
STRIDE] /=
ee;
return *
this; }
867 for (
int i=0;
i<M-1; ++
i, ++
nxt) {
895 for (
int i=0;
i<M; ++
i, ++
nxt) {
905 {
return *
reinterpret_cast<const Vec*
>(p); }
909 {
return *
reinterpret_cast<Vec*
>(p); }
919 for (
int i=0;
i<M; ++
i)
929 for (
int i=0;
i<M; ++
i) {
930 const ELT& e = (*this)[
i];
943 for (
int i=0;
i<M; ++
i)
955 template <
class E2,
int RS2>
957 for (
int i=0;
i<M; ++
i)
966 template <
class E2,
int RS2>
980 for (
int i=0;
i<M; ++
i)
996 { (*this)[
i] = value; }
1014template <
int M,
class E1,
int S1,
class E2,
int S2>
inline
1018 ::AddOp::perform(l,r);
1022template <
int M,
class E1,
int S1,
class E2,
int S2>
inline
1026 ::SubOp::perform(l,r);
1030template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
1032{
for (
int i=0; i < M; ++i)
if (l[i] != r[i])
return false;
1035template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
1039template <
int M,
class E1,
int S1,
class E2>
inline bool
1041{
for (
int i=0; i < M; ++i)
if (v[i] != e)
return false;
1044template <
int M,
class E1,
int S1,
class E2>
inline bool
1048template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
1050{
for (
int i=0; i < M; ++i)
if (l[i] >= r[i])
return false;
1053template <
int M,
class E1,
int S1,
class E2>
inline bool
1055{
for (
int i=0; i < M; ++i)
if (v[i] >= e)
return false;
1059template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
1061{
for (
int i=0; i < M; ++i)
if (l[i] <= r[i])
return false;
1064template <
int M,
class E1,
int S1,
class E2>
inline bool
1066{
for (
int i=0; i < M; ++i)
if (v[i] <= e)
return false;
1071template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
1073{
for (
int i=0; i < M; ++i)
if (l[i] > r[i])
return false;
1077template <
int M,
class E1,
int S1,
class E2>
inline bool
1079{
for (
int i=0; i < M; ++i)
if (v[i] > e)
return false;
1084template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool
1086{
for (
int i=0; i < M; ++i)
if (l[i] < r[i])
return false;
1090template <
int M,
class E1,
int S1,
class E2>
inline bool
1092{
for (
int i=0; i < M; ++i)
if (v[i] < e)
return false;
1106template <
int M,
class E,
int S>
inline
1110template <
int M,
class E,
int S>
inline
1114template <
int M,
class E,
int S>
inline
1118template <
int M,
class E,
int S>
inline
1123template <
int M,
class E,
int S>
inline
1126template <
int M,
class E,
int S>
inline
1133template <
int M,
class E,
int S,
class R>
inline
1137template <
int M,
class E,
int S,
class R>
inline
1142template <
int M,
class E,
int S,
class R>
inline
1145template <
int M,
class E,
int S,
class R>
inline
1150template <
int M,
class E,
int S,
class R>
inline
1153template <
int M,
class E,
int S,
class R>
inline
1163template <
int M,
class E,
int S>
inline
1167template <
int M,
class E,
int S>
inline
1168typename CNT<float>::template Result<Vec<M,E,S> >::Dvd
1172template <
int M,
class E,
int S>
inline
1176template <
int M,
class E,
int S>
inline
1177typename CNT<double>::template Result<Vec<M,E,S> >::Dvd
1182template <
int M,
class E,
int S>
inline
1185template <
int M,
class E,
int S>
inline
1186typename CNT<typename CNT<E>::Precision>::template Result<Vec<M,E,S> >::Dvd
1193template <
int M,
class E,
int S,
class R>
inline
1197template <
int M,
class E,
int S,
class R>
inline
1198typename CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Dvd
1203template <
int M,
class E,
int S,
class R>
inline
1206template <
int M,
class E,
int S,
class R>
inline
1207typename CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Dvd
1211template <
int M,
class E,
int S,
class R>
inline
1214template <
int M,
class E,
int S,
class R>
inline
1215typename CNT<R>::template Result<Vec<M,E,S> >::Dvd
1226template <
int M,
class E,
int S>
inline
1230template <
int M,
class E,
int S>
inline
1234template <
int M,
class E,
int S>
inline
1238template <
int M,
class E,
int S>
inline
1243template <
int M,
class E,
int S>
inline
1246template <
int M,
class E,
int S>
inline
1253template <
int M,
class E,
int S,
class R>
inline
1257template <
int M,
class E,
int S,
class R>
inline
1262template <
int M,
class E,
int S,
class R>
inline
1265template <
int M,
class E,
int S,
class R>
inline
1270template <
int M,
class E,
int S,
class R>
inline
1273template <
int M,
class E,
int S,
class R>
inline
1280template <
int M,
class E,
int S>
inline
1284template <
int M,
class E,
int S>
inline
1285typename CNT<float>::template Result<Vec<M,E,S> >::Sub
1289template <
int M,
class E,
int S>
inline
1293template <
int M,
class E,
int S>
inline
1294typename CNT<double>::template Result<Vec<M,E,S> >::Sub
1299template <
int M,
class E,
int S>
inline
1302template <
int M,
class E,
int S>
inline
1303typename CNT<typename CNT<E>::Precision>::template Result<Vec<M,E,S> >::Sub
1310template <
int M,
class E,
int S,
class R>
inline
1314template <
int M,
class E,
int S,
class R>
inline
1315typename CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Sub
1320template <
int M,
class E,
int S,
class R>
inline
1323template <
int M,
class E,
int S,
class R>
inline
1324typename CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Sub
1328template <
int M,
class E,
int S,
class R>
inline
1331template <
int M,
class E,
int S,
class R>
inline
1332typename CNT<R>::template Result<Vec<M,E,S> >::Sub
1336template <
int M,
class E,
int S,
class CHAR,
class TRAITS>
inline
1337std::basic_ostream<CHAR,TRAITS>&
1338operator<<(std::basic_ostream<CHAR,TRAITS>& o,
const Vec<M,E,S>& v) {
1339 o <<
"~[" << v[0];
for(
int i=1;i<M;++i) o<<
','<<v[i]; o<<
']';
return o;
1344template <
int M,
class E,
int S,
class CHAR,
class TRAITS>
inline
1345std::basic_istream<CHAR,TRAITS>&
1348 is >> tilde;
if (is.fail())
return is;
1349 if (tilde != CHAR(
'~')) {
1351 is.unget();
if (is.fail())
return is;
1354 CHAR openBracket, closeBracket;
1355 is >> openBracket;
if (is.fail())
return is;
1356 if (openBracket==CHAR(
'('))
1357 closeBracket = CHAR(
')');
1358 else if (openBracket==CHAR(
'['))
1359 closeBracket = CHAR(
']');
1361 closeBracket = CHAR(0);
1362 is.unget();
if (is.fail())
return is;
1367 if (tilde != CHAR(0) && closeBracket == CHAR(0)) {
1368 is.setstate( std::ios::failbit );
1372 for (
int i=0; i < M; ++i) {
1374 if (is.fail())
return is;
1376 CHAR c; is >> c;
if (is.fail())
return is;
1377 if (c !=
',') is.unget();
1378 if (is.fail())
return is;
1384 if (closeBracket != CHAR(0)) {
1385 CHAR closer; is >> closer;
if (is.fail())
return is;
1386 if (closer != closeBracket) {
1387 is.unget();
if (is.fail())
return is;
1388 is.setstate( std::ios::failbit );
Mandatory first inclusion for any Simbody source or header file.
Specialized information about Composite Numerical Types which allows us to define appropriate templat...
Definition CompositeNumericalTypes.h:136
static K getNaN()
Definition CompositeNumericalTypes.h:246
K::ULessScalar ULessScalar
Definition CompositeNumericalTypes.h:161
static double getDefaultTolerance()
Definition CompositeNumericalTypes.h:269
K::ScalarNormSq ScalarNormSq
Definition CompositeNumericalTypes.h:166
K::StdNumber StdNumber
Definition CompositeNumericalTypes.h:163
static TSqrt sqrt(const K &t)
Definition CompositeNumericalTypes.h:239
K::TSqHermT TSqHermT
Definition CompositeNumericalTypes.h:146
K::TSqrt TSqrt
Definition CompositeNumericalTypes.h:154
K::TInvert TInvert
Definition CompositeNumericalTypes.h:157
K::TNormalize TNormalize
Definition CompositeNumericalTypes.h:158
K::TWithoutNegator TWithoutNegator
Definition CompositeNumericalTypes.h:140
K::TReal TReal
Definition CompositeNumericalTypes.h:141
static TStandard standardize(const K &t)
Definition CompositeNumericalTypes.h:241
K::THerm THerm
Definition CompositeNumericalTypes.h:144
K::TPosTrans TPosTrans
Definition CompositeNumericalTypes.h:145
K::TNeg TNeg
Definition CompositeNumericalTypes.h:139
K::TStandard TStandard
Definition CompositeNumericalTypes.h:156
K::TComplex TComplex
Definition CompositeNumericalTypes.h:143
K::TSqTHerm TSqTHerm
Definition CompositeNumericalTypes.h:147
K::TImag TImag
Definition CompositeNumericalTypes.h:142
K::Precision Precision
Definition CompositeNumericalTypes.h:164
K::Scalar Scalar
Definition CompositeNumericalTypes.h:160
K::TAbs TAbs
Definition CompositeNumericalTypes.h:155
K::Number Number
Definition CompositeNumericalTypes.h:162
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition Mat.h:97
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
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
Vec & scalarMinusEq(const EE &ee)
Definition Vec.h:787
TSqrt sqrt() const
Elementwise square root; that is, the return value has the same length as this Vec but with each elem...
Definition Vec.h:337
bool isNumericallyEqual(const ELT &e, double tol=getDefaultTolerance()) const
Test whether every element of this vector is numerically equal to the given element,...
Definition Vec.h:977
void setToNaN()
Set every scalar in this Vec to NaN; this is the default initial value in Debug builds,...
Definition Vec.h:812
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
CNT< E >::TStandard EStandard
Return type of standardize(E) method; a packed type that can hold the value of an element after elimi...
Definition Vec.h:221
Vec(const ENeg &ne)
Construction from a single value of this Vec's negated element type assigns that value to each elemen...
Definition Vec.h:476
TPosTrans & updPositionalTranspose()
Positional transpose returning a writable reference.
Definition Vec.h:674
Row< M, EHerm, STRIDE > THerm
Type of this Vec after casting to its Hermitian transpose; that is, the Vec turns into a Row and each...
Definition Vec.h:284
CNT< E >::TWithoutNegator EWithoutNegator
Element type, stripped of negator<> if it has one.
Definition Vec.h:195
CNT< E >::Number ENumber
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:230
CNT< E >::TNeg ENeg
Negated version of this Vec's element type; ENeg==negator< E >.
Definition Vec.h:193
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
Vec< M+1, ELT, 1 > append1(const EE &v) const
Return a vector one larger than this one by adding an element to the end.
Definition Vec.h:877
ELT E
Element type of this Vec.
Definition Vec.h:191
Row< M, E, STRIDE > TPosTrans
Type of this Vec after casting to its positional transpose; that is, the Vec turns into a Row but the...
Definition Vec.h:287
Vec< M, E, STRIDE > T
The type of this Vec.
Definition Vec.h:265
void setToZero()
Set every scalar in this Vec to zero.
Definition Vec.h:817
Vec & operator=(const Vec &src)
Copy assignment operator copies the logically-included elements from the source Vec; gaps due to stri...
Definition Vec.h:445
EScalar Scalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:308
bool isNaN() const
Return true if any element of this Vec contains a NaN anywhere.
Definition Vec.h:918
Mat< M, M, typename CNT< E >::template Result< EE >::Mul > conformingMultiply(const Row< M, EE, SS > &r) const
Same as outer product (m = col*row) – use operator* or outer() instead.
Definition Vec.h:572
std::string toString() const
Print Vec into a string and return it.
Definition Vec.h:988
Vec & operator-=(const EE &e)
Definition Vec.h:777
CNT< E >::StdNumber EStdNumber
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:231
E TElement
Element type of this Vec.
Definition Vec.h:289
Vec & scalarPlusEq(const EE &ee)
Definition Vec.h:785
TInvert invert() const
This method is not supported for Vec objects.
Definition Vec.h:635
E & operator()(int i)
Same as non-const operator[] above.
Definition Vec.h:606
CNT< ScalarNormSq >::TSqrt norm() const
Definition Vec.h:610
Vec< M, typename CNT< E >::template Result< EE >::Dvd > scalarDivide(const EE &e) const
Definition Vec.h:739
Vec< M, EComplex, STRIDE > TComplex
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:280
Vec TCol
Type of a column of this CNT object (for a Vec, the whole thing).
Definition Vec.h:293
Vec< M, typename CNT< E >::template Result< EE >::Mul > elementwiseMultiply(const Vec< M, EE, SS > &r) const
Elementwise multiply (Matlab " .* " operator).
Definition Vec.h:580
Vec & scalarMinusEqFromLeft(int ee)
Definition Vec.h:806
const E & get(int i) const
Variant of operator[] that's scripting friendly to get const reference to ith entry.
Definition Vec.h:999
Vec< M, typename CNT< E >::template Result< EE >::Add > scalarAdd(const EE &e) const
Definition Vec.h:752
Vec< M, EAbs, 1 > TAbs
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:298
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
Vec< M, typename CNT< EE >::template Result< E >::Sub > scalarSubtractFromLeft(const EE &e) const
Definition Vec.h:766
CNT< E >::ULessScalar EULessScalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:229
bool isFinite() const
Return true if no element of this Vec contains an Infinity or a NaN anywhere.
Definition Vec.h:942
Vec(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)
Definition Vec.h:499
Vec & operator=(const EE *p)
Assignment to a pointer to elements of any type EE assumes we're pointing at a C++ array of EE's of t...
Definition Vec.h:523
CNT< E >::TNormalize ENormalize
Packed type that can hold the value returned from normalize(E).
Definition Vec.h:226
static int ncol()
The number of columns in a Vec is always 1.
Definition Vec.h:322
TNeg & updNegate()
Non-operator version of unary negation; recasts and returns a writable reference.
Definition Vec.h:659
Vec & operator=(const Vec< M, EE, SS > &vv)
Assignment to a conforming Vec, of any element type and stride, provided that the element types are a...
Definition Vec.h:528
Vec(const Vec< M, ENeg, SS > &src)
This is an implicit conversion from a Vec of the same length and negated element type (possibly with ...
Definition Vec.h:458
Vec< M-1, ELT, 1 > drop1(int p) const
Return a vector one smaller than this one by dropping the element at the indicated position p.
Definition Vec.h:863
Vec(int i)
Given an int value, turn it into a suitable floating point number, convert that to element type E and...
Definition Vec.h:485
Vec(const E &e0, const E &e1)
Construct a Vec<2,E> from two elements of type E, etc.
Definition Vec.h:490
Vec(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6)
Definition Vec.h:502
Vec< M, EWithoutNegator, STRIDE > TWithoutNegator
Type of this Vec with negator removed from its element type, if the element is negated.
Definition Vec.h:271
Vec< M, ENormalize, 1 > TNormalize
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:301
Vec< M, typename CNT< EE >::template Result< E >::Mul > scalarMultiplyFromLeft(const EE &e) const
Definition Vec.h:730
TImag & imag()
Recast to show only the imaginary portion of this Vec and return a writable reference.
Definition Vec.h:699
Vec & scalarTimesEqFromLeft(int ee)
Definition Vec.h:807
Vec< M, typename CNT< E >::template Result< EE >::Sub > conformingSubtract(const Vec< M, EE, SS > &r) const
Vector subtraction – use operator- instead.
Definition Vec.h:563
TWithoutNegator & updCastAwayNegatorIfAny()
Recast to remove negators from this Vec's type if present and return a writable reference.
Definition Vec.h:712
static const Vec & getSubVec(const Vec< MM, ELT, STRIDE > &v, int i)
Extract a subvector of type Vec from a longer one that has the same element type and stride,...
Definition Vec.h:847
Vec & operator+=(const EE &e)
Definition Vec.h:776
Vec< M, ESqrt, 1 > TSqrt
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:297
Vec(const E &e0, const E &e1, const E &e2)
Definition Vec.h:492
THerm & operator~()
Recast to Hermitian transposed type and return a writable reference; the effect is that writing to el...
Definition Vec.h:653
Vec(const E &e0, const E &e1, const E &e2, const E &e3)
Definition Vec.h:494
Vec & operator-=(const Vec< M, negator< EE >, SS > &r)
Subtract off a conforming Vec, of any negated element type and stride, provided that the element type...
Definition Vec.h:548
ScalarNormSq scalarNormSqr() const
Scalar norm square is sum( conjugate squares of all underlying scalars ), where conjugate square of s...
Definition Vec.h:327
Vec & scalarMinusEq(int ee)
Definition Vec.h:803
Vec< M, typename CNT< E >::template Result< EE >::Dvd > elementwiseDivide(const Vec< M, EE, SS > &r) const
Elementwise divide (Matlab " ./ " operator).
Definition Vec.h:587
Vec(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4)
Definition Vec.h:496
static double getDefaultTolerance()
For approximate comparisons, the default tolerance to use for a vector is the same as its elements' d...
Definition Vec.h:951
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
Vec()
Default construction initializes Vec's elements to NaN when debugging but leaves them uninitialized g...
Definition Vec.h:425
const TWithoutNegator & castAwayNegatorIfAny() const
Recast to remove negators from this Vec's type if present; this is handy for simplifying operations w...
Definition Vec.h:708
static Vec< M, ELT, 1 > getNaN()
Return a Vec of the same length and element type as this one but with all elements set to NaN.
Definition Vec.h:915
Vec< M, typename CNT< E >::template Result< EE >::Add > conformingAdd(const Vec< M, EE, SS > &r) const
Vector addition – use operator+ instead.
Definition Vec.h:556
Vec & scalarEq(const EE &ee)
Definition Vec.h:783
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
Vec< M, typename CNT< E >::template Result< EE >::Sub > scalarSubtract(const EE &e) const
Definition Vec.h:760
ScalarNormSq normSqr() const
Definition Vec.h:608
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
TStandard standardize() const
Return a copy of this Vec but with the underlying scalar type converted (if necessary) to one of the ...
Definition Vec.h:357
Vec< M, typename CNT< EE >::template Result< E >::Dvd > scalarDivideFromLeft(const EE &e) const
Definition Vec.h:745
Vec & scalarMinusEqFromLeft(const EE &ee)
Definition Vec.h:789
const TNeg & negate() const
Non-operator version of unary negation; just a recast.
Definition Vec.h:656
void set(int i, const E &value)
Variant of operator[] that's scripting friendly to set ith entry.
Definition Vec.h:995
CNT< E >::TAbs EAbs
Type required to hold the result of abs(E).
Definition Vec.h:218
Vec & scalarDivideEqFromLeft(int ee)
Definition Vec.h:808
const TNeg & operator-() const
Unary minus recasts this Vec to a type that has the opposite interpretation of the sign but is otherw...
Definition Vec.h:642
Vec & scalarDivideEq(const EE &ee)
Definition Vec.h:795
Vec & operator+=(const Vec< M, EE, SS > &r)
Add in a conforming Vec, of any element type and stride, provided that the element types are addition...
Definition Vec.h:533
static int nrow()
The number of rows in a Vec is the number of elements.
Definition Vec.h:320
Vec & scalarTimesEq(int ee)
Definition Vec.h:804
Vec(const EE *p)
Construction from a pointer to elements of any type EE assumes we're pointing at a C++ array of EE's ...
Definition Vec.h:516
CNT< E >::TSqHermT ESqHermT
Type of the expression ~E*E (default vector and matrix square; symmetric).
Definition Vec.h:212
CNT< E >::TReal EReal
Type showing just the real part of an element of this Vec if elements are complex; otherwise just the...
Definition Vec.h:198
THerm & updTranspose()
Non-operator version of Hermitian transpose; recasts and returns a writable reference.
Definition Vec.h:665
CNT< E >::TComplex EComplex
Type that elements would have if complex, if E is currently real; otherwise just the element type E.
Definition Vec.h:205
CNT< E >::TPosTrans EPosTrans
Type of a positional transpose of an element of this Vec.
Definition Vec.h:209
Vec & operator+=(const Vec< M, negator< EE >, SS > &r)
Add in a conforming Vec, of any negated element type and stride, provided that the element types are ...
Definition Vec.h:538
static Vec & updSubVec(Vec< MM, ELT, STRIDE > &v, int i)
Extract a subvector of type Vec from a longer one that has the same element type and stride,...
Definition Vec.h:855
TReal & real()
Recast to show only the real portion of this Vec and return a writable reference.
Definition Vec.h:684
CNT< E >::Precision EPrecision
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:232
ESqHermT TSqHermT
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:303
CNT< E >::ScalarNormSq EScalarNormSq
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:233
Vec(const E &e)
Construction from a single value of this Vec's element type assigns that value to each element.
Definition Vec.h:470
const TImag & imag() const
Return a reference to the imaginary portion of this Vec if it has complex elements; otherwise the typ...
Definition Vec.h:692
Vec & scalarDivideEqFromLeft(const EE &ee)
Definition Vec.h:797
Vec & operator*=(const EE &e)
Definition Vec.h:778
Vec< M, typename CNT< E >::template Result< EE >::Mul > scalarMultiply(const EE &e) const
Definition Vec.h:724
EScalarNormSq ScalarNormSq
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:313
@ SignInterpretation
Definition Vec.h:257
@ IsStdNumber
Definition Vec.h:255
@ IsULessScalar
Definition Vec.h:253
@ NRows
Definition Vec.h:239
@ ArgDepth
Definition Vec.h:249
@ RealStrideFactor
Definition Vec.h:247
@ ColSpacing
Definition Vec.h:245
@ NPackedElements
Definition Vec.h:241
@ IsNumber
Definition Vec.h:254
@ IsPrecision
Definition Vec.h:256
@ RowSpacing
Definition Vec.h:244
@ NActualElements
Definition Vec.h:242
@ NCols
Definition Vec.h:240
@ ImagOffset
Definition Vec.h:246
@ IsScalar
Definition Vec.h:252
@ NActualScalars
Definition Vec.h:243
CNT< E >::TImag EImag
Type showing the imaginary part of an element of this Vec as real, if elements are complex; otherwise...
Definition Vec.h:202
const TPosTrans & positionalTranspose() const
Positional transpose turns this Vec into a Row but does not transpose the individual elements.
Definition Vec.h:671
TNeg & operator-()
Recast to negated type and return a writable reference; writing to this will cause the negated result...
Definition Vec.h:645
EULessScalar ULessScalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:309
const E & operator[](int i) const
Select an element of this Vec and return a const reference to it.
Definition Vec.h:596
Vec< M, EImag, STRIDE *CNT< E >::RealStrideFactor > TImag
Type of this Vec cast to show only the imaginary part of its element; this might affect the stride.
Definition Vec.h:279
Vec & scalarDivideEq(int ee)
Definition Vec.h:805
Vec< M, EStandard, 1 > TStandard
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:299
ENumber Number
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:310
Vec(const Vec &src)
Copy constructor copies the logically-included elements from the source Vec; gaps due to stride are n...
Definition Vec.h:438
Vec< MM, ELT, STRIDE > & updSubVec(int i)
Extract a writable reference to a sub-Vec with size known at compile time.
Definition Vec.h:837
Vec(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)
Definition Vec.h:508
Vec(const Vec< M, E, SS > &src)
This is an implicit conversion from a Vec of the same length and element type but with a different st...
Definition Vec.h:452
Vec< M+1, ELT, 1 > insert1(int p, const EE &v) const
Return a vector one larger than this one by inserting an element before the indicated one.
Definition Vec.h:890
CNT< E >::TSqrt ESqrt
Type required to hold the result of sqrt(E).
Definition Vec.h:216
const THerm & operator~() const
The Hermitian transpose operator recasts this Vec to a type that specifies the opposite storage order...
Definition Vec.h:649
Vec< M, ENeg, STRIDE > TNeg
Type this Vec would have if its elements were interpreted as negated.
Definition Vec.h:268
Vec(const Vec< M, EE, SS > &src)
Construct a Vec from a Vec of the same length, with any stride.
Definition Vec.h:464
TAbs abs() const
Elementwise absolute value; that is, the return value has the same dimension as this Vec but with eac...
Definition Vec.h:347
bool isNumericallyEqual(const Vec< M, E2, RS2 > &v) const
Test whether this vector is numerically equal to some other vector with the same shape,...
Definition Vec.h:967
static int size()
The number of elements in this Vec (note that stride does not affect this number.)
Definition Vec.h:318
Row< M, EInvert, 1 > TInvert
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:300
E TRow
Type of a row of this CNT object (for a Vec, just its element type).
Definition Vec.h:291
const Vec & operator+() const
Unary plus does nothing.
Definition Vec.h:638
const E & operator()(int i) const
Same as const operator[] above.
Definition Vec.h:599
Vec(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7)
Definition Vec.h:505
Vec & scalarTimesEqFromLeft(const EE &ee)
Definition Vec.h:793
Vec & scalarTimesEq(const EE &ee)
Definition Vec.h:791
E & operator[](int i)
Select an element of this Vec and return a writable reference to it.
Definition Vec.h:604
Vec & scalarPlusEq(int ee)
Definition Vec.h:802
Vec & operator-=(const Vec< M, EE, SS > &r)
Subtract off a conforming Vec, of any element type and stride, provided that the element types are ad...
Definition Vec.h:543
Vec & operator/=(const EE &e)
Definition Vec.h:779
Vec< M, EReal, STRIDE *CNT< E >::RealStrideFactor > TReal
Type of this Vec cast to show only the real part of its element; this might affect the stride.
Definition Vec.h:275
EStdNumber StdNumber
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:311
CNT< E >::TSqTHerm ESqTHerm
Type of the expression E*~E ("row square"; symmetric).
Definition Vec.h:214
CNT< E >::TInvert EInvert
Packed type that can hold the value returned from invert(E), the inverse type of an element.
Definition Vec.h:224
const Vec< MM, ELT, STRIDE > & getSubVec(int i) const
Extract a const reference to a sub-Vec with size known at compile time.
Definition Vec.h:827
CNT< E >::THerm EHerm
Type of the Hermitian transpose of an element of this Vec.
Definition Vec.h:207
EPrecision Precision
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:312
Vec & scalarEq(int ee)
Definition Vec.h:801
const THerm & transpose() const
Non-operator version of Hermitian transpose; just a recast.
Definition Vec.h:662
SymMat< M, ESqTHerm > TSqTHerm
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:304
CNT< E >::Scalar EScalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition Vec.h:228
SimTK::conjugate<R> should be instantiated only for float, double.
Definition conjugate.h:178
negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically...
Definition negator.h:75
NTraits< N >::StdNumber StdNumber
Definition negator.h:107
void copy(Row< 1, E1, S1 > &r1, const Row< 1, E2, S2 > &r2)
Definition Row.h:105
void elementwiseDivide(const Row< 1, E1, S1 > &r1, const Row< 1, E2, S2 > &r2, Row< 1, typename CNT< E1 >::template Result< E2 >::Dvd > &result)
Definition Row.h:90
void conformingSubtract(const Row< 1, E1, S1 > &r1, const Row< 1, E2, S2 > &r2, Row< 1, typename CNT< E1 >::template Result< E2 >::Sub > &result)
Definition Row.h:60
void conformingAdd(const Row< 1, E1, S1 > &r1, const Row< 1, E2, S2 > &r2, Row< 1, typename CNT< E1 >::template Result< E2 >::Add > &result)
Definition Row.h:45
void elementwiseMultiply(const Row< 1, E1, S1 > &r1, const Row< 1, E2, S2 > &r2, Row< 1, typename CNT< E1 >::template Result< E2 >::Mul > &result)
Definition Row.h:75
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
Matrix_< E > operator/(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition BigMatrix.h:613
std::basic_istream< CHAR, TRAITS > & operator>>(std::basic_istream< CHAR, TRAITS > &is, conjugate< R > &c)
Definition conjugate.h:505
bool operator>(const L &left, const R &right)
Definition SimTKcommon/include/SimTKcommon/internal/common.h:647
@ MAX_RESOLVED_DEPTH
Definition CompositeNumericalTypes.h:120
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
bool operator>=(const L &left, const R &right)
Definition SimTKcommon/include/SimTKcommon/internal/common.h:659
bool operator<(const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
bool = v1[i] < v2[i], for all elements i
Definition Row.h:822
bool operator<=(const L &left, const R &right)
Definition SimTKcommon/include/SimTKcommon/internal/common.h:653
bool operator==(const PhiMatrix &p1, const PhiMatrix &p2)
Definition SpatialAlgebra.h:791
bool operator!=(const L &left, const R &right)
Definition SimTKcommon/include/SimTKcommon/internal/common.h:641
Vec< M, typename CNT< E >::template Result< P >::Sub, 1 > Sub
Definition Vec.h:381
Vec< M, typename CNT< E >::template Result< P >::Mul, 1 > Mul
Definition Vec.h:378
Vec< M, typename CNT< E >::template Result< P >::Dvd, 1 > Dvd
Definition Vec.h:379
Vec< M, typename CNT< E >::template Result< P >::Add, 1 > Add
Definition Vec.h:380
DvdOp::Type Dvd
Definition Vec.h:400
MulCNTsNonConforming< M, 1, ArgDepth, Vec, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > MulOpNonConforming
Definition Vec.h:394
DvdCNTs< M, 1, ArgDepth, Vec, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > DvdOp
Definition Vec.h:399
AddCNTs< M, 1, ArgDepth, Vec, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > AddOp
Definition Vec.h:404
MulOp::Type Mul
Definition Vec.h:390
MulCNTs< M, 1, ArgDepth, Vec, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > MulOp
Definition Vec.h:389
AddOp::Type Add
Definition Vec.h:405
SubCNTs< M, 1, ArgDepth, Vec, ColSpacing, RowSpacing, CNT< P >::NRows, CNT< P >::NCols, CNT< P >::ArgDepth, P, CNT< P >::ColSpacing, CNT< P >::RowSpacing > SubOp
Definition Vec.h:409
MulOpNonConforming::Type MulNon
Definition Vec.h:395
SubOp::Type Sub
Definition Vec.h:410
Shape-preserving element substitution (always packed).
Definition Vec.h:418
Vec< M, P > Type
Definition Vec.h:419