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 1020 template <
int M,
class E1,
int S1,
class E2,
int S2>
inline 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
that is
Definition: SimmathUserGuide.doc:215
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
Apache License January AND DISTRIBUTION Definitions License shall mean the terms and conditions for and distribution as defined by Sections through of this document Licensor shall mean the copyright owner or entity authorized by the copyright owner that is granting the License Legal Entity shall mean the union of the acting entity and all other entities that control are controlled by or are under common control with that entity For the purposes of this definition control direct or to cause the direction or management of such whether by contract or including but not limited to software source documentation and configuration files Object form shall mean any form resulting from mechanical transformation or translation of a Source including but not limited to compiled object generated and conversions to other media types Work shall mean the work of whether in Source or Object made available under the as indicated by a copyright notice that is included in or attached to the whether in Source or Object that is based or other modifications as a an original work of authorship For the purposes of this Derivative Works shall not include works that remain separable or merely the Work and Derivative Works thereof Contribution shall mean any work of including the original version of the Work and any modifications or additions to that Work or Derivative Works that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner For the purposes of this submitted means any form of or written communication sent to the Licensor or its including but not limited to communication on electronic mailing source code control and issue tracking systems that are managed or on behalf the Licensor for the purpose of discussing and improving the but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as Not a Contribution Contributor shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work Grant of Copyright License Subject to the terms and conditions of this each Contributor hereby grants to You a non no royalty irrevocable copyright license to prepare Derivative Works publicly publicly perform
Definition: LICENSE.txt:44
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
╨╧ рб▒ с ■ ╖ ╣ ■ │ ┤ ╡ ╢ ье┴ А ° ┐ ч bjbjcTcT ┌┘ │ ├ ╗ t ╖ Я ┴ K K K D П П П А Л2 Ф П Z╞ j J a n u a r A b s t r a c t W e d e s c r i b e t h e g o a l s a n d d e s i g n d e c i s i o n b e h i n d S i m m a t r i t h e S i m T K m a t r i x a n d l i n e a r a l g e b r a l i b r a r a n d p r o v i d e r e f e r e n c e i n f o r m a t i o n f o r u s i n g i t T h e i d e a i s t o p r o v i d e t h e p o w e r
Definition: Simmatrix.doc:7
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