1 #ifndef SimTK_SIMMATRIX_SMALLMATRIX_VEC_H_ 2 #define SimTK_SIMMATRIX_SMALLMATRIX_VEC_H_ 46 template <
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];
51 template <
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];
61 template <
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];
66 template <
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];
76 template <
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];
81 template <
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];
91 template <
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];
96 template <
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];
106 template <
class E1,
int S1,
class E2,
int S2>
void 107 copy(Vec<1,E1,S1>& r1,
const Vec<1,E2,S2>& r2) {
110 template <
int N,
class E1,
int S1,
class E2,
int S2>
void 111 copy(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));
183 template <
int M,
class ELT,
int STRIDE>
241 NActualElements = M * STRIDE,
244 ColSpacing = NActualElements,
246 RealStrideFactor = 1,
316 static int size() {
return M; }
318 static int nrow() {
return M; }
320 static int ncol() {
return 1; }
327 for(
int i=0;i<M;++i) sum += CNT<E>::scalarNormSqr(d[i*STRIDE]);
337 for(
int i=0;i<M;++i) vsqrt[i] = CNT<E>::sqrt(d[i*STRIDE]);
357 for(
int i=0;i<M;++i) vstd[i] = CNT<E>::standardize(d[i*STRIDE]);
366 for (
int i=0;i<M;++i) sum += d[i*STRIDE];
385 typedef MulCNTs<M,1,ArgDepth,
Vec,ColSpacing,RowSpacing,
388 typedef typename MulOp::Type
Mul;
390 typedef MulCNTsNonConforming<M,1,ArgDepth,Vec,ColSpacing,RowSpacing,
391 CNT<P>::NRows, CNT<P>::NCols, CNT<P>::ArgDepth,
393 typedef typename MulOpNonConforming::Type
MulNon;
395 typedef DvdCNTs<M,1,ArgDepth,Vec,ColSpacing,RowSpacing,
396 CNT<P>::NRows, CNT<P>::NCols, CNT<P>::ArgDepth,
398 typedef typename DvdOp::Type
Dvd;
400 typedef AddCNTs<M,1,ArgDepth,Vec,ColSpacing,RowSpacing,
401 CNT<P>::NRows, CNT<P>::NCols, CNT<P>::ArgDepth,
403 typedef typename AddOp::Type
Add;
405 typedef SubCNTs<M,1,ArgDepth,Vec,ColSpacing,RowSpacing,
406 CNT<P>::NRows, CNT<P>::NCols, CNT<P>::ArgDepth,
408 typedef typename SubOp::Type
Sub;
468 explicit Vec(
const E& e) {
for (
int i=0;i<M;++i) d[i*STRIDE]=e;}
474 explicit Vec(
const ENeg& ne) {
476 for (
int i=0;i<M;++i) d[i*STRIDE]=e;
483 explicit Vec(
int i) {
new (
this)
Vec(
E(Precision(i)));}
488 Vec(
const E& e0,
const E& e1)
489 { assert(M==2);(*this)[0]=e0;(*this)[1]=e1; }
490 Vec(
const E& e0,
const E& e1,
const E& e2)
491 { assert(M==3);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2; }
492 Vec(
const E& e0,
const E& e1,
const E& e2,
const E& e3)
493 { assert(M==4);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2;(*this)[3]=e3; }
494 Vec(
const E& e0,
const E& e1,
const E& e2,
const E& e3,
const E& e4)
495 { assert(M==5);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2;
496 (*this)[3]=e3;(*this)[4]=e4; }
497 Vec(
const E& e0,
const E& e1,
const E& e2,
const E& e3,
const E& e4,
const E& e5)
498 { assert(M==6);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2;
499 (*this)[3]=e3;(*this)[4]=e4;(*this)[5]=e5; }
500 Vec(
const E& e0,
const E& e1,
const E& e2,
const E& e3,
const E& e4,
const E& e5,
const E& e6)
501 { assert(M==7);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2;
502 (*this)[3]=e3;(*this)[4]=e4;(*this)[5]=e5;(*this)[6]=e6; }
503 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)
504 { assert(M==8);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2;
505 (*this)[3]=e3;(*this)[4]=e4;(*this)[5]=e5;(*this)[6]=e6;(*this)[7]=e7; }
506 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)
507 { assert(M==9);(*this)[0]=e0;(*this)[1]=e1;(*this)[2]=e2;
508 (*this)[3]=e3;(*this)[4]=e4;(*this)[5]=e5;(*this)[6]=e6;(*this)[7]=e7;(*this)[8]=e8; }
514 template <
class EE>
explicit Vec(
const EE* p)
515 { assert(p);
for(
int i=0;i<M;++i) d[i*STRIDE]=p[i]; }
522 { assert(p);
for(
int i=0;i<M;++i) d[i*STRIDE]=p[i];
return *
this; }
532 {
for(
int i=0;i<M;++i) d[i*STRIDE] += r[i];
return *
this; }
537 {
for(
int i=0;i<M;++i) d[i*STRIDE] -= -(r[i]);
return *
this; }
542 {
for(
int i=0;i<M;++i) d[i*STRIDE] -= r[i];
return *
this; }
547 {
for(
int i=0;i<M;++i) d[i*STRIDE] += -(r[i]);
return *
this; }
572 for (
int j=0;j<M;++j) result(j) = scalarMultiply(r(j));
595 { assert(0 <= i && i < M);
return d[i*STRIDE]; }
602 E&
operator[](
int i) {assert(0 <= i && i < M);
return d[i*STRIDE];}
606 ScalarNormSq
normSqr()
const {
return scalarNormSqr(); }
623 return castAwayNegatorIfAny() / (SignInterpretation*
norm());
625 TNormalize elementwiseNormalized;
626 for (
int i=0; i<M; ++i)
628 return elementwiseNormalized;
633 TInvert
invert()
const {assert(
false);
return TInvert();}
654 const TNeg&
negate()
const {
return *
reinterpret_cast<const TNeg*
>(
this); }
657 TNeg&
updNegate() {
return *
reinterpret_cast< TNeg*
>(
this); }
660 const THerm&
transpose()
const {
return *
reinterpret_cast<const THerm*
>(
this); }
670 {
return *
reinterpret_cast<const TPosTrans*
>(
this); }
673 {
return *
reinterpret_cast<TPosTrans*
>(
this); }
691 const int offs = ImagOffset;
692 const EImag* p =
reinterpret_cast<const EImag*
>(
this);
693 return *
reinterpret_cast<const TImag*
>(p+offs);
698 const int offs = ImagOffset;
699 EImag* p =
reinterpret_cast<EImag*
>(
this);
700 return *
reinterpret_cast<TImag*
>(p+offs);
707 {
return *
reinterpret_cast<const TWithoutNegator*
>(
this); }
711 {
return *
reinterpret_cast<TWithoutNegator*
>(
this); }
724 for (
int i=0; i<M; ++i) result[i] = (*
this)[i] * e;
730 for (
int i=0; i<M; ++i) result[i] = e * (*
this)[i];
739 for (
int i=0; i<M; ++i) result[i] = (*
this)[i] / e;
745 for (
int i=0; i<M; ++i) result[i] = e / (*
this)[i];
752 for (
int i=0; i<M; ++i) result[i] = (*
this)[i] + e;
760 for (
int i=0; i<M; ++i) result[i] = (*
this)[i] - e;
766 for (
int i=0; i<M; ++i) result[i] = e - (*
this)[i];
773 template <
class EE>
Vec& operator =(
const EE& e) {
return scalarEq(e);}
777 template <
class EE>
Vec&
operator/=(
const EE& e) {
return scalarDivideEq(e);}
782 {
for(
int i=0;i<M;++i) d[i*STRIDE] = ee;
return *
this; }
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 - d[i*STRIDE];
return *
this; }
790 {
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 * d[i*STRIDE];
return *
this; }
794 {
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 / d[i*STRIDE];
return *
this; }
826 assert(0 <= i && i + MM <= M);
836 assert(0 <= i && i + MM <= M);
846 assert(0 <= i && i + M <= MM);
854 assert(0 <= i && i + M <= MM);
862 assert(0 <= p && p < M);
865 for (
int i=0; i<M-1; ++i, ++nxt) {
867 out[i] = (*this)[nxt];
889 assert(0 <= p && p <= M);
890 if (p==M)
return append1(v);
893 for (
int i=0; i<M; ++i, ++nxt) {
894 if (i==p) out[nxt++] = v;
895 out[nxt] = (*this)[i];
903 {
return *
reinterpret_cast<const Vec*
>(p); }
907 {
return *
reinterpret_cast<Vec*
>(p); }
917 for (
int i=0; i<M; ++i)
926 bool seenInf =
false;
927 for (
int i=0; i<M; ++i) {
928 const ELT& e = (*this)[i];
941 for (
int i=0; i<M; ++i)
953 template <
class E2,
int RS2>
955 for (
int i=0; i<M; ++i)
964 template <
class E2,
int RS2>
966 const double tol =
std::max(getDefaultTolerance(),v.getDefaultTolerance());
976 double tol = getDefaultTolerance())
const 978 for (
int i=0; i<M; ++i)
987 std::stringstream stream;
993 void set(
int i,
const E& value)
994 { (*this)[i] = value; }
997 const E&
get(
int i)
const 998 {
return operator[](i); }
1003 ELT d[NActualElements];
1012 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline 1016 ::AddOp::perform(l,r);
1020 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline 1024 ::SubOp::perform(l,r);
1028 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool 1030 {
for (
int i=0; i < M; ++i)
if (l[i] != r[i])
return false;
1033 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool 1037 template <
int M,
class E1,
int S1,
class E2>
inline bool 1039 {
for (
int i=0; i < M; ++i)
if (v[i] != e)
return false;
1042 template <
int M,
class E1,
int S1,
class E2>
inline bool 1046 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool 1048 {
for (
int i=0; i < M; ++i) if (l[i] >= r[i])
return false;
1051 template <
int M,
class E1,
int S1,
class E2>
inline bool 1052 operator<(const Vec<M,E1,S1>& v,
const E2& e)
1053 {
for (
int i=0; i < M; ++i) if (v[i] >= e)
return false;
1057 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool 1059 {
for (
int i=0; i < M; ++i)
if (l[i] <= r[i])
return false;
1062 template <
int M,
class E1,
int S1,
class E2>
inline bool 1064 {
for (
int i=0; i < M; ++i)
if (v[i] <= e)
return false;
1069 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool 1071 {
for (
int i=0; i < M; ++i) if (l[i] > r[i])
return false;
1075 template <
int M,
class E1,
int S1,
class E2>
inline bool 1076 operator<=(const Vec<M,E1,S1>& v,
const E2& e)
1077 {
for (
int i=0; i < M; ++i) if (v[i] > e)
return false;
1082 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline bool 1084 {
for (
int i=0; i < M; ++i)
if (l[i] < r[i])
return false;
1088 template <
int M,
class E1,
int S1,
class E2>
inline bool 1090 {
for (
int i=0; i < M; ++i)
if (v[i] < e)
return false;
1104 template <
int M,
class E,
int S>
inline 1108 template <
int M,
class E,
int S>
inline 1112 template <
int M,
class E,
int S>
inline 1116 template <
int M,
class E,
int S>
inline 1120 template <
int M,
class E,
int S>
inline 1124 template <
int M,
class E,
int S>
inline 1129 template <
int M,
class E,
int S>
inline 1132 template <
int M,
class E,
int S>
inline 1139 template <
int M,
class E,
int S,
class R>
inline 1143 template <
int M,
class E,
int S,
class R>
inline 1148 template <
int M,
class E,
int S,
class R>
inline 1151 template <
int M,
class E,
int S,
class R>
inline 1156 template <
int M,
class E,
int S,
class R>
inline 1159 template <
int M,
class E,
int S,
class R>
inline 1169 template <
int M,
class E,
int S>
inline 1173 template <
int M,
class E,
int S>
inline 1178 template <
int M,
class E,
int S>
inline 1182 template <
int M,
class E,
int S>
inline 1187 template <
int M,
class E,
int S>
inline 1191 template <
int M,
class E,
int S>
inline 1197 template <
int M,
class E,
int S>
inline 1200 template <
int M,
class E,
int S>
inline 1208 template <
int M,
class E,
int S,
class R>
inline 1212 template <
int M,
class E,
int S,
class R>
inline 1218 template <
int M,
class E,
int S,
class R>
inline 1221 template <
int M,
class E,
int S,
class R>
inline 1226 template <
int M,
class E,
int S,
class R>
inline 1229 template <
int M,
class E,
int S,
class R>
inline 1241 template <
int M,
class E,
int S>
inline 1245 template <
int M,
class E,
int S>
inline 1249 template <
int M,
class E,
int S>
inline 1253 template <
int M,
class E,
int S>
inline 1257 template <
int M,
class E,
int S>
inline 1261 template <
int M,
class E,
int S>
inline 1266 template <
int M,
class E,
int S>
inline 1269 template <
int M,
class E,
int S>
inline 1276 template <
int M,
class E,
int S,
class R>
inline 1280 template <
int M,
class E,
int S,
class R>
inline 1285 template <
int M,
class E,
int S,
class R>
inline 1288 template <
int M,
class E,
int S,
class R>
inline 1293 template <
int M,
class E,
int S,
class R>
inline 1296 template <
int M,
class E,
int S,
class R>
inline 1303 template <
int M,
class E,
int S>
inline 1307 template <
int M,
class E,
int S>
inline 1312 template <
int M,
class E,
int S>
inline 1316 template <
int M,
class E,
int S>
inline 1321 template <
int M,
class E,
int S>
inline 1325 template <
int M,
class E,
int S>
inline 1331 template <
int M,
class E,
int S>
inline 1334 template <
int M,
class E,
int S>
inline 1342 template <
int M,
class E,
int S,
class R>
inline 1346 template <
int M,
class E,
int S,
class R>
inline 1352 template <
int M,
class E,
int S,
class R>
inline 1355 template <
int M,
class E,
int S,
class R>
inline 1360 template <
int M,
class E,
int S,
class R>
inline 1363 template <
int M,
class E,
int S,
class R>
inline 1368 template <
int M,
class E,
int S,
class CHAR,
class TRAITS>
inline 1369 std::basic_ostream<CHAR,TRAITS>&
1370 operator<<(std::basic_ostream<CHAR,TRAITS>& o,
const Vec<M,E,S>& v) {
1371 o <<
"~[" << v[0];
for(
int i=1;i<M;++i) o<<
','<<v[i]; o<<
']';
return o;
1376 template <
int M,
class E,
int S,
class CHAR,
class TRAITS>
inline 1377 std::basic_istream<CHAR,TRAITS>&
1380 is >> tilde;
if (is.fail())
return is;
1381 if (tilde != CHAR(
'~')) {
1383 is.unget();
if (is.fail())
return is;
1386 CHAR openBracket, closeBracket;
1387 is >> openBracket;
if (is.fail())
return is;
1388 if (openBracket==CHAR(
'('))
1389 closeBracket = CHAR(
')');
1390 else if (openBracket==CHAR(
'['))
1391 closeBracket = CHAR(
']');
1393 closeBracket = CHAR(0);
1394 is.unget();
if (is.fail())
return is;
1399 if (tilde != CHAR(0) && closeBracket == CHAR(0)) {
1400 is.setstate( std::ios::failbit );
1404 for (
int i=0; i < M; ++i) {
1406 if (is.fail())
return is;
1408 CHAR c; is >> c;
if (is.fail())
return is;
1409 if (c !=
',') is.unget();
1410 if (is.fail())
return is;
1416 if (closeBracket != CHAR(0)) {
1417 CHAR closer; is >> closer;
if (is.fail())
return is;
1418 if (closer != closeBracket) {
1419 is.unget();
if (is.fail())
return is;
1420 is.setstate( std::ios::failbit );
1430 #endif //SimTK_SIMMATRIX_SMALLMATRIX_VEC_H_ Matrix_< E > operator/(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:613
TImag & imag()
Recast to show only the imaginary portion of this Vec and return a writable reference.
Definition: Vec.h:697
PhiMatrixTranspose transpose(const PhiMatrix &phi)
Definition: SpatialAlgebra.h:720
std::string toString() const
Print Vec into a string and return it.
Definition: Vec.h:986
bool isFinite() const
Return true if no element of this Vec contains an Infinity or a NaN anywhere.
Definition: Vec.h:940
TAbs abs() const
Elementwise absolute value; that is, the return value has the same dimension as this Vec but with eac...
Definition: Vec.h:345
CNT< E >::TSqHermT ESqHermT
Type of the expression ~E*E (default vector and matrix square; symmetric).
Definition: Vec.h:212
K::ScalarNormSq ScalarNormSq
Definition: CompositeNumericalTypes.h:166
SubOp::Type Sub
Definition: Vec.h:408
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:913
K::ULessScalar ULessScalar
Definition: CompositeNumericalTypes.h:161
TNeg & operator-()
Recast to negated type and return a writable reference; writing to this will cause the negated result...
Definition: Vec.h:643
static int size()
The number of elements in this Vec (note that stride does not affect this number.) ...
Definition: Vec.h:316
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:506
Vec< M, P > Type
Definition: Vec.h:417
K::TReal TReal
Definition: CompositeNumericalTypes.h:141
CNT< E >::TSqrt ESqrt
Type required to hold the result of sqrt(E).
Definition: Vec.h:216
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:690
ScalarNormSq scalarNormSqr() const
Scalar norm square is sum( conjugate squares of all underlying scalars ), where conjugate square of s...
Definition: Vec.h:325
Vec< M, typename CNT< E >::template Result< EE >::Dvd > elementwiseDivide(const Vec< M, EE, SS > &r) const
Elementwise divide (Matlab " ./ " operator).
Definition: Vec.h:585
This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:608
const E & operator[](int i) const
Select an element of this Vec and return a const reference to it.
Definition: Vec.h:594
SymMat< M, ESqTHerm > TSqTHerm
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:302
Vec< M, typename CNT< EE >::template Result< E >::Sub > scalarSubtractFromLeft(const EE &e) const
Definition: Vec.h:764
Vec & scalarEq(const EE &ee)
Definition: Vec.h:781
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
MulOp::Type Mul
Definition: Vec.h:388
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
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:335
Vec & scalarTimesEq(const EE &ee)
Definition: Vec.h:789
Vec & scalarTimesEqFromLeft(int ee)
Definition: Vec.h:805
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
bool isNaN() const
Return true if any element of this Vec contains a NaN anywhere.
Definition: Vec.h:916
NTraits< N >::StdNumber StdNumber
Definition: negator.h:107
SimTK::conjugate<R> should be instantiated only for float, double, long double.
Definition: String.h:45
K::TSqrt TSqrt
Definition: CompositeNumericalTypes.h:154
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:861
TWithoutNegator & updCastAwayNegatorIfAny()
Recast to remove negators from this Vec's type if present and return a writable reference.
Definition: Vec.h:710
Vec(const E &e)
Construction from a single value of this Vec's element type assigns that value to each element...
Definition: Vec.h:468
TInvert invert() const
This method is not supported for Vec objects.
Definition: Vec.h:633
static TSqrt sqrt(const K &t)
Definition: CompositeNumericalTypes.h:239
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:906
Vec< M, ESqrt, 1 > TSqrt
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:295
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:521
TNeg & updNegate()
Non-operator version of unary negation; recasts and returns a writable reference. ...
Definition: Vec.h:657
K::Scalar Scalar
Definition: CompositeNumericalTypes.h:160
ESqHermT TSqHermT
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:301
Vec & operator+=(const EE &e)
Definition: Vec.h:774
CNT< E >::TNormalize ENormalize
Packed type that can hold the value returned from normalize(E).
Definition: Vec.h:226
K::TNormalize TNormalize
Definition: CompositeNumericalTypes.h:158
Vec< M, typename CNT< EE >::template Result< E >::Mul > scalarMultiplyFromLeft(const EE &e) const
Definition: Vec.h:728
Matrix_< typename CNT< E1 >::template Result< E2 >::Sub > operator-(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:584
E TElement
Element type of this Vec.
Definition: Vec.h:287
Vec< M, typename CNT< E >::template Result< EE >::Mul > elementwiseMultiply(const Vec< M, EE, SS > &r) const
Elementwise multiply (Matlab " .* " operator).
Definition: Vec.h:578
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:500
static int nrow()
The number of rows in a Vec is the number of elements.
Definition: Vec.h:318
E & operator[](int i)
Select an element of this Vec and return a writable reference to it.
Definition: Vec.h:602
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:503
K::TImag TImag
Definition: CompositeNumericalTypes.h:142
CNT< E >::StdNumber EStdNumber
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:231
Vec(const E &e0, const E &e1)
Construct a Vec<2,E> from two elements of type E, etc.
Definition: Vec.h:488
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:355
Vec< M, typename CNT< E >::template Result< P >::Mul, 1 > Mul
Definition: Vec.h:376
Vec & operator-=(const EE &e)
Definition: Vec.h:775
EStdNumber StdNumber
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:309
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:402
std::basic_istream< CHAR, TRAITS > & operator>>(std::basic_istream< CHAR, TRAITS > &is, conjugate< R > &c)
Definition: conjugate.h:800
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:514
Vec< M, EAbs, 1 > TAbs
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:296
negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically...
Definition: String.h:44
Definition: CompositeNumericalTypes.h:120
static double getDefaultTolerance()
Definition: CompositeNumericalTypes.h:269
CNT< E >::THerm EHerm
Type of the Hermitian transpose of an element of this Vec.
Definition: Vec.h:207
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:888
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:640
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:407
TPosTrans & updPositionalTranspose()
Positional transpose returning a writable reference.
Definition: Vec.h:672
Vec(const Vec &src)
Copy constructor copies the logically-included elements from the source Vec; gaps due to stride are n...
Definition: Vec.h:436
bool operator==(const PhiMatrix &p1, const PhiMatrix &p2)
Definition: SpatialAlgebra.h:774
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
static TStandard standardize(const K &t)
Definition: CompositeNumericalTypes.h:241
Vec(const E &e0, const E &e1, const E &e2, const E &e3)
Definition: Vec.h:492
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:273
CNT< E >::Scalar EScalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:228
EPrecision Precision
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:310
CNT< E >::TPosTrans EPosTrans
Type of a positional transpose of an element of this Vec.
Definition: Vec.h:209
CNT< E >::TSqTHerm ESqTHerm
Type of the expression E*~E ("row square"; symmetric).
Definition: Vec.h:214
Vec< M, typename CNT< E >::template Result< P >::Add, 1 > Add
Definition: Vec.h:378
Vec< M, EStandard, 1 > TStandard
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:297
Vec & scalarMinusEqFromLeft(int ee)
Definition: Vec.h:804
Vec & scalarPlusEq(const EE &ee)
Definition: Vec.h:783
const E & operator()(int i) const
Same as const operator[] above.
Definition: Vec.h:597
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:536
Vec< M, E, STRIDE > T
The type of this Vec.
Definition: Vec.h:263
CNT< E >::ScalarNormSq EScalarNormSq
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:233
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:570
ELEM sum(const VectorBase< ELEM > &v)
Definition: VectorMath.h:147
K::TSqTHerm TSqTHerm
Definition: CompositeNumericalTypes.h:147
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:456
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:364
This is a fixed-length column vector designed for no-overhead inline computation. ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:605
const Vec & operator+() const
Unary plus does nothing.
Definition: Vec.h:636
Row< M, EInvert, 1 > TInvert
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:298
const TNeg & negate() const
Non-operator version of unary negation; just a recast.
Definition: Vec.h:654
Vec(const Vec< M, EE, SS > &src)
Construct a Vec from a Vec of the same length, with any stride.
Definition: Vec.h:462
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:679
const THerm & operator~() const
The Hermitian transpose operator recasts this Vec to a type that specifies the opposite storage order...
Definition: Vec.h:647
Vec< M, typename CNT< E >::template Result< EE >::Mul > scalarMultiply(const EE &e) const
Definition: Vec.h:722
static double getDefaultTolerance()
For approximate comparisions, the default tolerance to use for a vector is the same as its elements' ...
Definition: Vec.h:949
K::Precision Precision
Definition: CompositeNumericalTypes.h:164
Vec & scalarEq(int ee)
Definition: Vec.h:799
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:282
ENumber Number
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:308
void setToNaN()
Set every scalar in this Vec to NaN; this is the default initial value in Debug builds, but not in Release.
Definition: Vec.h:810
Matrix_< E > operator*(const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
Definition: BigMatrix.h:605
Vec< M, typename CNT< E >::template Result< EE >::Add > scalarAdd(const EE &e) const
Definition: Vec.h:750
void setToZero()
Set every scalar in this Vec to zero.
Definition: Vec.h:815
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
K::TInvert TInvert
Definition: CompositeNumericalTypes.h:157
THerm & operator~()
Recast to Hermitian transposed type and return a writable reference; the effect is that writing to el...
Definition: Vec.h:651
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, using a specified tolerance.
Definition: Vec.h:954
Vec & operator=(const Vec &src)
Copy assignment operator copies the logically-included elements from the source Vec; gaps due to stri...
Definition: Vec.h:443
Vec(const E &e0, const E &e1, const E &e2)
Definition: Vec.h:490
MulOpNonConforming::Type MulNon
Definition: Vec.h:393
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
Vec & scalarMinusEq(int ee)
Definition: Vec.h:801
Shape-preserving element substitution (always packed).
Definition: Vec.h:416
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:554
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:392
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:621
Vec & operator/=(const EE &e)
Definition: Vec.h:777
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:845
bool operator>=(const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2).
Definition: Row.h:858
CNT< E >::TWithoutNegator EWithoutNegator
Element type, stripped of negator<> if it has one.
Definition: Vec.h:195
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
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:474
K::TPosTrans TPosTrans
Definition: CompositeNumericalTypes.h:145
Vec & operator*=(const EE &e)
Definition: Vec.h:776
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
float norm(const conjugate< float > &c)
Definition: conjugate.h:775
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:277
TReal & real()
Recast to show only the real portion of this Vec and return a writable reference. ...
Definition: Vec.h:682
const TPosTrans & positionalTranspose() const
Positional transpose turns this Vec into a Row but does not transpose the individual elements...
Definition: Vec.h:669
CNT< E >::TAbs EAbs
Type required to hold the result of abs(E).
Definition: Vec.h:218
K::StdNumber StdNumber
Definition: CompositeNumericalTypes.h:163
RowVectorBase< typename CNT< ELEM >::TAbs > abs(const RowVectorBase< ELEM > &v)
Definition: VectorMath.h:120
Vec & scalarTimesEqFromLeft(const EE &ee)
Definition: Vec.h:791
bool operator!=(const conjugate< R > &a, const float &b)
Definition: conjugate.h:859
E TRow
Type of a row of this CNT object (for a Vec, just its element type).
Definition: Vec.h:289
Specialized information about Composite Numerical Types which allows us to define appropriate templat...
Definition: CompositeNumericalTypes.h:136
Vec & scalarPlusEq(int ee)
Definition: Vec.h:800
THerm & updTranspose()
Non-operator version of Hermitian transpose; recasts and returns a writable reference.
Definition: Vec.h:663
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:397
Vec & scalarDivideEq(int ee)
Definition: Vec.h:803
CNT< E >::Precision EPrecision
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:232
This is a fixed-length row vector designed for no-overhead inline computation.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:606
Vec & scalarMinusEqFromLeft(const EE &ee)
Definition: Vec.h:787
const Real E
e = Real(exp(1))
Mandatory first inclusion for any Simbody source or header file.
Vec< M, ENormalize, 1 > TNormalize
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:299
E & operator()(int i)
Same as non-const operator[] above.
Definition: Vec.h:604
Vec< M, typename CNT< E >::template Result< EE >::Sub > scalarSubtract(const EE &e) const
Definition: Vec.h:758
K::TNeg TNeg
Definition: CompositeNumericalTypes.h:139
K::TStandard TStandard
Definition: CompositeNumericalTypes.h:156
void copy(Row< 1, E1, S1 > &r1, const Row< 1, E2, S2 > &r2)
Definition: Row.h:105
ScalarNormSq normSqr() const
Definition: Vec.h:606
K::TWithoutNegator TWithoutNegator
Definition: CompositeNumericalTypes.h:140
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:526
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
const THerm & transpose() const
Non-operator version of Hermitian transpose; just a recast.
Definition: Vec.h:660
CNT< ScalarNormSq >::TSqrt norm() const
Definition: Vec.h:608
Vec< MM, ELT, STRIDE > & updSubVec(int i)
Extract a writable reference to a sub-Vec with size known at compile time.
Definition: Vec.h:835
Vec< M, typename CNT< E >::template Result< P >::Sub, 1 > Sub
Definition: Vec.h:379
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
Matrix_< typename CNT< E1 >::template Result< E2 >::Add > operator+(const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
Definition: BigMatrix.h:568
Vec< M, EComplex, STRIDE > TComplex
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:278
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:875
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:825
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:607
Vec & scalarDivideEqFromLeft(int ee)
Definition: Vec.h:806
K::TComplex TComplex
Definition: CompositeNumericalTypes.h:143
Vec & scalarTimesEq(int ee)
Definition: Vec.h:802
K::Number Number
Definition: CompositeNumericalTypes.h:162
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:531
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:285
bool isInf() const
Return true if any element of this Vec contains a +Infinity or -Infinity somewhere but no element con...
Definition: Vec.h:925
Vec & scalarDivideEq(const EE &ee)
Definition: Vec.h:793
static K getNaN()
Definition: CompositeNumericalTypes.h:246
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:546
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:853
Vec(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4)
Definition: Vec.h:494
Vec< M, ENeg, STRIDE > TNeg
Type this Vec would have if its elements were interpreted as negated.
Definition: Vec.h:266
CNT< E >::Number ENumber
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:230
ELT E
Element type of this Vec.
Definition: Vec.h:191
EScalarNormSq ScalarNormSq
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:311
K::TSqHermT TSqHermT
Definition: CompositeNumericalTypes.h:146
bool isNumericallyEqual(const Vec< M, E2, RS2 > &v) const
Test whether this vector is numerically equal to some other vector with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared.
Definition: Vec.h:965
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:833
Vec(const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)
Definition: Vec.h:497
CNT< E >::ULessScalar EULessScalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:229
AddOp::Type Add
Definition: Vec.h:403
Vec TCol
Type of a column of this CNT object (for a Vec, the whole thing).
Definition: Vec.h:291
EULessScalar ULessScalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:307
K::THerm THerm
Definition: CompositeNumericalTypes.h:144
Vec()
Default construction initializes Vec's elements to NaN when debugging but leaves them uninitialized g...
Definition: Vec.h:423
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:561
Vec< M, typename CNT< E >::template Result< EE >::Dvd > scalarDivide(const EE &e) const
Definition: Vec.h:737
Vec & scalarMinusEq(const EE &ee)
Definition: Vec.h:785
static int ncol()
The number of columns in a Vec is always 1.
Definition: Vec.h:320
EScalar Scalar
These compile-time constants are required of every Composite Numerical Type (CNT).
Definition: Vec.h:306
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:450
Vec & scalarDivideEqFromLeft(const EE &ee)
Definition: Vec.h:795
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:706
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:483
CNT< E >::TNeg ENeg
Negated version of this Vec's element type; ENeg==negator< E >.
Definition: Vec.h:193
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
Vec< M, typename CNT< EE >::template Result< E >::Dvd > scalarDivideFromLeft(const EE &e) const
Definition: Vec.h:743
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:541
DvdOp::Type Dvd
Definition: Vec.h:398
Vec< M, EWithoutNegator, STRIDE > TWithoutNegator
Type of this Vec with negator removed from its element type, if the element is negated.
Definition: Vec.h:269
Vec< M, typename CNT< E >::template Result< P >::Dvd, 1 > Dvd
Definition: Vec.h:377
static const Vec & getAs(const ELT *p)
Recast an ordinary C++ array E[] to a const Vec<M,E,S>; assumes compatible length, stride, and packing.
Definition: Vec.h:902
K::TAbs TAbs
Definition: CompositeNumericalTypes.h:155
bool isNumericallyEqual(const float &a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
Compare two floats for approximate equality.
Definition: NTraits.h:313
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:387