Simbody  3.5
VectorBase.h
Go to the documentation of this file.
1 #ifndef SimTK_SIMMATRIX_VECTORBASE_H_
2 #define SimTK_SIMMATRIX_VECTORBASE_H_
3 
4 /* -------------------------------------------------------------------------- *
5  * Simbody(tm): SimTKcommon *
6  * -------------------------------------------------------------------------- *
7  * This is part of the SimTK biosimulation toolkit originating from *
8  * Simbios, the NIH National Center for Physics-Based Simulation of *
9  * Biological Structures at Stanford, funded under the NIH Roadmap for *
10  * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11  * *
12  * Portions copyright (c) 2005-13 Stanford University and the Authors. *
13  * Authors: Michael Sherman *
14  * Contributors: *
15  * *
16  * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17  * not use this file except in compliance with the License. You may obtain a *
18  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19  * *
20  * Unless required by applicable law or agreed to in writing, software *
21  * distributed under the License is distributed on an "AS IS" BASIS, *
22  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23  * See the License for the specific language governing permissions and *
24  * limitations under the License. *
25  * -------------------------------------------------------------------------- */
26 
31 namespace SimTK {
32 
33 //==============================================================================
34 // VECTOR BASE
35 //==============================================================================
42 template <class ELT> class VectorBase : public MatrixBase<ELT> {
43  typedef MatrixBase<ELT> Base;
44  typedef typename Base::ScalarNormSq ScalarNormSq;
45  typedef typename Base::EAbs EAbs;
46  typedef typename CNT<ELT>::Scalar Scalar;
47  typedef typename CNT<ELT>::Number Number;
48  typedef typename CNT<ELT>::StdNumber StdNumber;
49  typedef VectorBase<ELT> T;
50  typedef VectorBase<typename CNT<ELT>::TAbs> TAbs;
51  typedef VectorBase<typename CNT<ELT>::TNeg> TNeg;
52  typedef RowVectorView_<typename CNT<ELT>::THerm> THerm;
53 public:
54  // ------------------------------------------------------------------------
64 
67  explicit VectorBase(int m=0) : Base(MatrixCommitment::Vector(), m, 1) {}
68 
72  VectorBase(const VectorBase& source) : Base(source) {}
73 
75  VectorBase(const TNeg& source) : Base(source) {}
76 
79  VectorBase(int m, const ELT& initialValue)
80  : Base(MatrixCommitment::Vector(),m,1,initialValue) {}
81 
86  VectorBase(int m, const ELT* cppInitialValues)
87  : Base(MatrixCommitment::Vector(),m,1,cppInitialValues) {}
89 
90  // ------------------------------------------------------------------------
99 
101  VectorBase(int m, int stride, const Scalar* s)
102  : Base(MatrixCommitment::Vector(m), MatrixCharacter::Vector(m),stride,s) { }
104  VectorBase(int m, int stride, Scalar* s)
105  : Base(MatrixCommitment::Vector(m), MatrixCharacter::Vector(m),stride,s) { }
107 
108  // ------------------------------------------------------------------------
115 
118  : Base(MatrixCommitment::Vector(), h,s) { }
121  : Base(MatrixCommitment::Vector(), h,s) { }
124  : Base(MatrixCommitment::Vector(), h,d) { }
126 
127  // This gives the resulting vector type when (v[i] op P) is applied to each element.
128  // It will have element types which are the regular composite result of ELT op P.
129  template <class P> struct EltResult {
134  };
135 
139  Base::operator=(b); return *this;
140  }
141 
142  // default destructor
143 
144 
145  VectorBase& operator*=(const StdNumber& t) { Base::operator*=(t); return *this; }
146  VectorBase& operator/=(const StdNumber& t) { Base::operator/=(t); return *this; }
147  VectorBase& operator+=(const VectorBase& r) { Base::operator+=(r); return *this; }
148  VectorBase& operator-=(const VectorBase& r) { Base::operator-=(r); return *this; }
149 
150 
151  template <class EE> VectorBase& operator=(const VectorBase<EE>& b)
152  { Base::operator=(b); return *this; }
153  template <class EE> VectorBase& operator+=(const VectorBase<EE>& b)
154  { Base::operator+=(b); return *this; }
155  template <class EE> VectorBase& operator-=(const VectorBase<EE>& b)
156  { Base::operator-=(b); return *this; }
157 
158 
162  VectorBase& operator=(const ELT& t) { Base::setTo(t); return *this; }
163 
168  template <class EE> VectorBase& rowScaleInPlace(const VectorBase<EE>& v)
169  { Base::template rowScaleInPlace<EE>(v); return *this; }
170  template <class EE> inline void rowScale(const VectorBase<EE>& v, typename EltResult<EE>::Mul& out) const
171  { Base::rowScale(v,out); }
172  template <class EE> inline typename EltResult<EE>::Mul rowScale(const VectorBase<EE>& v) const
173  { typename EltResult<EE>::Mul out(nrow()); Base::rowScale(v,out); return out; }
174 
179  typename CNT<ScalarNormSq>::TSqrt
180  normRMS(int* worstOne=0) const {
181  if (!CNT<ELT>::IsScalar)
183  "Vector::normRMS() only defined for scalar elements.");
184  const int n = nrow();
185  if (n == 0) {
186  if (worstOne) *worstOne = -1;
187  return typename CNT<ScalarNormSq>::TSqrt(0);
188  }
189 
190  ScalarNormSq sumsq = 0;
191  if (worstOne) {
192  *worstOne = 0;
193  ScalarNormSq maxsq = 0;
194  for (int i=0; i<n; ++i) {
195  const ScalarNormSq v2 = square((*this)[i]);
196  if (v2 > maxsq) maxsq=v2, *worstOne=i;
197  sumsq += v2;
198  }
199  } else { // don't track the worst element
200  for (int i=0; i<n; ++i) {
201  const ScalarNormSq v2 = square((*this)[i]);
202  sumsq += v2;
203  }
204  }
205 
206  return CNT<ScalarNormSq>::sqrt(sumsq/n);
207  }
208 
214  template <class EE>
215  typename CNT<ScalarNormSq>::TSqrt
216  weightedNormRMS(const VectorBase<EE>& w, int* worstOne=0) const {
219  "Vector::weightedNormRMS() only defined for scalar elements"
220  " and weights.");
221  const int n = nrow();
222  assert(w.nrow()==n);
223  if (n == 0) {
224  if (worstOne) *worstOne = -1;
225  return typename CNT<ScalarNormSq>::TSqrt(0);
226  }
227 
228  ScalarNormSq sumsq = 0;
229  if (worstOne) {
230  *worstOne = 0;
231  ScalarNormSq maxsq = 0;
232  for (int i=0; i<n; ++i) {
233  const ScalarNormSq wv2 = square(w[i]*(*this)[i]);
234  if (wv2 > maxsq) maxsq=wv2, *worstOne=i;
235  sumsq += wv2;
236  }
237  } else { // don't track the worst element
238  for (int i=0; i<n; ++i) {
239  const ScalarNormSq wv2 = square(w[i]*(*this)[i]);
240  sumsq += wv2;
241  }
242  }
243 
244  return CNT<ScalarNormSq>::sqrt(sumsq/n);
245  }
246 
251  EAbs normInf(int* worstOne=0) const {
252  if (!CNT<ELT>::IsScalar)
254  "Vector::normInf() only defined for scalar elements.");
255  const int n = nrow();
256  if (n == 0) {
257  if (worstOne) *worstOne = -1;
258  return EAbs(0);
259  }
260 
261  EAbs maxabs = 0;
262  if (worstOne) {
263  *worstOne = 0;
264  for (int i=0; i<n; ++i) {
265  const EAbs a = std::abs((*this)[i]);
266  if (a > maxabs) maxabs=a, *worstOne=i;
267  }
268  } else { // don't track the worst element
269  for (int i=0; i<n; ++i) {
270  const EAbs a = std::abs((*this)[i]);
271  if (a > maxabs) maxabs=a;
272  }
273  }
274 
275  return maxabs;
276  }
277 
283  template <class EE>
284  EAbs weightedNormInf(const VectorBase<EE>& w, int* worstOne=0) const {
287  "Vector::weightedNormInf() only defined for scalar elements"
288  " and weights.");
289  const int n = nrow();
290  assert(w.nrow()==n);
291  if (n == 0) {
292  if (worstOne) *worstOne = -1;
293  return EAbs(0);
294  }
295 
296  EAbs maxabs = 0;
297  if (worstOne) {
298  *worstOne = 0;
299  for (int i=0; i<n; ++i) {
300  const EAbs wv = std::abs(w[i]*(*this)[i]);
301  if (wv > maxabs) maxabs=wv, *worstOne=i;
302  }
303  } else { // don't track the worst element
304  for (int i=0; i<n; ++i) {
305  const EAbs wv = std::abs(w[i]*(*this)[i]);
306  if (wv > maxabs) maxabs=wv;
307  }
308  }
309 
310  return maxabs;
311  }
312 
316  return *this;
317  }
318 
320  void elementwiseInvert(VectorBase<typename CNT<ELT>::TInvert>& out) const {
322  }
323 
328  return out;
329  }
330 
331  // elementwise multiply
333  { Base::template elementwiseMultiplyInPlace<EE>(r); return *this; }
334  template <class EE> inline void elementwiseMultiply(const VectorBase<EE>& v, typename EltResult<EE>::Mul& out) const
335  { Base::template elementwiseMultiply<EE>(v,out); }
336  template <class EE> inline typename EltResult<EE>::Mul elementwiseMultiply(const VectorBase<EE>& v) const
337  { typename EltResult<EE>::Mul out(nrow()); Base::template elementwiseMultiply<EE>(v,out); return out; }
338 
339  // elementwise multiply from left
341  { Base::template elementwiseMultiplyFromLeftInPlace<EE>(r); return *this; }
342  template <class EE> inline void
344  const VectorBase<EE>& v,
345  typename VectorBase<EE>::template EltResult<ELT>::Mul& out) const
346  {
347  Base::template elementwiseMultiplyFromLeft<EE>(v,out);
348  }
349  template <class EE> inline typename VectorBase<EE>::template EltResult<ELT>::Mul
351  {
353  Base::template elementwiseMultiplyFromLeft<EE>(v,out);
354  return out;
355  }
356 
357  // elementwise divide
359  { Base::template elementwiseDivideInPlace<EE>(r); return *this; }
360  template <class EE> inline void elementwiseDivide(const VectorBase<EE>& v, typename EltResult<EE>::Dvd& out) const
361  { Base::template elementwiseDivide<EE>(v,out); }
362  template <class EE> inline typename EltResult<EE>::Dvd elementwiseDivide(const VectorBase<EE>& v) const
363  { typename EltResult<EE>::Dvd out(nrow()); Base::template elementwiseDivide<EE>(v,out); return out; }
364 
365  // elementwise divide from left
367  { Base::template elementwiseDivideFromLeftInPlace<EE>(r); return *this; }
368  template <class EE> inline void
370  const VectorBase<EE>& v,
371  typename VectorBase<EE>::template EltResult<ELT>::Dvd& out) const
372  {
373  Base::template elementwiseDivideFromLeft<EE>(v,out);
374  }
375  template <class EE> inline typename VectorBase<EE>::template EltResult<ELT>::Dvd
377  {
379  Base::template elementwiseDivideFromLeft<EE>(v,out);
380  return out;
381  }
382 
383  // Implicit conversions are allowed to Vector or Matrix, but not to RowVector.
384  operator const Vector_<ELT>&() const { return *reinterpret_cast<const Vector_<ELT>*>(this); }
385  operator Vector_<ELT>&() { return *reinterpret_cast< Vector_<ELT>*>(this); }
386  operator const VectorView_<ELT>&() const { return *reinterpret_cast<const VectorView_<ELT>*>(this); }
387  operator VectorView_<ELT>&() { return *reinterpret_cast< VectorView_<ELT>*>(this); }
388 
389  operator const Matrix_<ELT>&() const { return *reinterpret_cast<const Matrix_<ELT>*>(this); }
390  operator Matrix_<ELT>&() { return *reinterpret_cast< Matrix_<ELT>*>(this); }
391  operator const MatrixView_<ELT>&() const { return *reinterpret_cast<const MatrixView_<ELT>*>(this); }
392  operator MatrixView_<ELT>&() { return *reinterpret_cast< MatrixView_<ELT>*>(this); }
393 
394 
395  // size() for Vectors is Base::nelt() but returns int instead of ptrdiff_t.
396  int size() const {
397  assert(Base::nelt() <= (ptrdiff_t)std::numeric_limits<int>::max());
398  assert(Base::ncol()==1);
399  return (int)Base::nelt();
400  }
401  int nrow() const {assert(Base::ncol()==1); return Base::nrow();}
402  int ncol() const {assert(Base::ncol()==1); return Base::ncol();}
403  ptrdiff_t nelt() const {assert(Base::ncol()==1); return Base::nelt();}
404 
405  // Override MatrixBase operators to return the right shape
406  TAbs abs() const {TAbs result; Base::abs(result); return result;}
407 
408  // Override MatrixBase indexing operators
409  const ELT& operator[](int i) const {return *reinterpret_cast<const ELT*>(Base::getHelper().getElt(i));}
410  ELT& operator[](int i) {return *reinterpret_cast<ELT*> (Base::updHelper().updElt(i));}
411  const ELT& operator()(int i) const {return *reinterpret_cast<const ELT*>(Base::getHelper().getElt(i));}
412  ELT& operator()(int i) {return *reinterpret_cast<ELT*> (Base::updHelper().updElt(i));}
413 
414  // Block (contiguous subvector) view creation
415  VectorView_<ELT> operator()(int i, int m) const {return Base::operator()(i,0,m,1).getAsVectorView();}
416  VectorView_<ELT> operator()(int i, int m) {return Base::operator()(i,0,m,1).updAsVectorView();}
417 
418  // Indexed view creation (arbitrary subvector). Indices must be
419  // monotonically increasing.
420  VectorView_<ELT> index(const Array_<int>& indices) const {
422  Base::getHelper(), indices);
423  return VectorView_<ELT>(h);
424  }
427  Base::updHelper(), indices);
428  return VectorView_<ELT>(h);
429  }
430 
431  VectorView_<ELT> operator()(const Array_<int>& indices) const {return index(indices);}
432  VectorView_<ELT> operator()(const Array_<int>& indices) {return updIndex(indices);}
433 
434  // Hermitian transpose.
435  THerm transpose() const {return Base::transpose().getAsRowVectorView();}
436  THerm updTranspose() {return Base::updTranspose().updAsRowVectorView();}
437 
438  THerm operator~() const {return transpose();}
439  THerm operator~() {return updTranspose();}
440 
441  const VectorBase& operator+() const {return *this; }
442 
443  // Negation
444 
445  const TNeg& negate() const {return *reinterpret_cast<const TNeg*>(this); }
446  TNeg& updNegate() {return *reinterpret_cast<TNeg*>(this); }
447 
448  const TNeg& operator-() const {return negate();}
449  TNeg& operator-() {return updNegate();}
450 
451  VectorBase& resize(int m) {Base::resize(m,1); return *this;}
452  VectorBase& resizeKeep(int m) {Base::resizeKeep(m,1); return *this;}
453 
454  //TODO: this is not re-locking the number of columns at 1.
455  void clear() {Base::clear(); Base::resize(0,1);}
456 
457  ELT sum() const {ELT s; Base::getHelper().sum(reinterpret_cast<Scalar*>(&s)); return s; } // add all the elements
459  return VectorIterator<ELT, VectorBase<ELT> >(*this, 0);
460  }
462  return VectorIterator<ELT, VectorBase<ELT> >(*this, size());
463  }
464 
465 protected:
466  // Create a VectorBase handle using a given helper rep.
467  explicit VectorBase(MatrixHelperRep<Scalar>* hrep) : Base(hrep) {}
468 
469 private:
470  // NO DATA MEMBERS ALLOWED
471 };
472 
473 } //namespace SimTK
474 
475 #endif // SimTK_SIMMATRIX_VECTORBASE_H_
VectorView_< ELT > operator()(int j) const
Definition: MatrixBase.h:595
void elementwiseDivide(const VectorBase< EE > &v, typename EltResult< EE >::Dvd &out) const
Definition: VectorBase.h:360
VectorBase & operator-=(const VectorBase &r)
Definition: VectorBase.h:148
VectorIterator< ELT, VectorBase< ELT > > begin()
Definition: VectorBase.h:458
VectorBase & operator/=(const StdNumber &t)
Definition: VectorBase.h:146
EScalarNormSq ScalarNormSq
Definition: MatrixBase.h:101
THerm updTranspose()
Definition: VectorBase.h:436
Definition: MatrixHelper.h:48
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 source
Definition: LICENSE.txt:26
const MatrixCommitment & getCharacterCommitment() const
Definition: MatrixBase.h:119
VectorBase(const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::DeepCopy &d)
Construct a new owner vector initialized with the data from the source.
Definition: VectorBase.h:123
VectorBase & operator=(const VectorBase< EE > &b)
Definition: VectorBase.h:151
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
K::TSqrt TSqrt
Definition: CompositeNumericalTypes.h:154
MatrixHelper< Scalar > & updHelper()
Definition: MatrixBase.h:866
static TSqrt sqrt(const K &t)
Definition: CompositeNumericalTypes.h:239
VectorBase & operator=(const VectorBase &b)
Copy assignment is deep copy but behavior depends on type of lhs: if view, rhs must match...
Definition: VectorBase.h:138
MatrixBase< typename CNT< E >::TInvert > elementwiseInvert() const
Definition: MatrixBase.h:453
K::Scalar Scalar
Definition: CompositeNumericalTypes.h:160
A MatrixCharacter is a set containing a value for each of the matrix characteristics except element t...
Definition: MatrixCharacteristics.h:597
EAbs weightedNormInf(const VectorBase< EE > &w, int *worstOne=0) const
Return the weighted infinity norm (max absolute value) WInf of a Vector of scalars, with optional return of the index of the weighted element of largest absolute value.
Definition: VectorBase.h:284
const TNeg & operator-() const
Definition: VectorBase.h:448
int size() const
Definition: VectorBase.h:396
MatrixBase & operator/=(const StdNumber &t)
Definition: MatrixBase.h:291
MatrixBase & resizeKeep(int m, int n)
Change the size of this matrix, retaining as much of the old data as will fit.
Definition: MatrixBase.h:780
VectorView_< ELT > operator()(int i, int m) const
Definition: VectorBase.h:415
VectorBase< typename CNT< ELT >::template Result< P >::Add > Add
Definition: VectorBase.h:132
EltResult< EE >::Mul elementwiseMultiply(const VectorBase< EE > &v) const
Definition: VectorBase.h:336
Definition: Exception.h:297
int ncol() const
Definition: VectorBase.h:402
VectorBase< typename CNT< ELT >::template Result< P >::Mul > Mul
Definition: VectorBase.h:130
void elementwiseMultiply(const VectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
Definition: VectorBase.h:334
VectorBase< EE >::template EltResult< ELT >::Mul elementwiseMultiplyFromLeft(const VectorBase< EE > &v) const
Definition: VectorBase.h:350
void elementwiseMultiplyFromLeft(const VectorBase< EE > &v, typename VectorBase< EE >::template EltResult< ELT >::Mul &out) const
Definition: VectorBase.h:343
MatrixBase & operator-=(const MatrixBase &r)
Definition: MatrixBase.h:293
MatrixBase & operator*=(const StdNumber &t)
Definition: MatrixBase.h:290
S * updElt(int i, int j)
TNeg & operator-()
Definition: VectorBase.h:449
VectorBase & operator-=(const VectorBase< EE > &b)
Definition: VectorBase.h:155
VectorBase & operator+=(const VectorBase &r)
Definition: VectorBase.h:147
unsigned char square(unsigned char u)
Definition: Scalar.h:351
VectorView_< ELT > updIndex(const Array_< int > &indices)
Definition: VectorBase.h:425
void elementwiseDivideFromLeft(const VectorBase< EE > &v, typename VectorBase< EE >::template EltResult< ELT >::Dvd &out) const
Definition: VectorBase.h:369
m
Definition: CMakeCache.txt:469
VectorBase & operator+=(const VectorBase< EE > &b)
Definition: VectorBase.h:153
VectorBase(const VectorBase &source)
Copy constructor is a deep copy (not appropriate for views!).
Definition: VectorBase.h:72
VectorBase & elementwiseDivideFromLeftInPlace(const VectorBase< EE > &r)
Definition: VectorBase.h:366
VectorBase< typename CNT< ELT >::template Result< P >::Dvd > Dvd
Definition: VectorBase.h:131
VectorBase(const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
Construct a read-only view of the source data.
Definition: VectorBase.h:120
VectorBase(const TNeg &source)
Implicit conversion from compatible vector with negated elements.
Definition: VectorBase.h:75
MatrixView_< EHerm > transpose() const
Definition: BigMatrix.h:222
VectorBase & rowScaleInPlace(const VectorBase< EE > &v)
There&#39;s only one column here so it&#39;s a bit weird to use rowScale rather than elementwiseMultiply, but there&#39;s nothing really wrong with it.
Definition: VectorBase.h:168
This is an iterator for iterating over the elements of a Vector_ or Vec object.
Definition: BigMatrix.h:176
THerm operator~()
Definition: VectorBase.h:439
VectorView_< ELT > operator()(const Array_< int > &indices)
Definition: VectorBase.h:432
int nrow() const
Return the number of rows m in the logical shape of this matrix.
Definition: MatrixBase.h:137
ELT sum() const
Definition: VectorBase.h:457
VectorView_< ELT > operator()(const Array_< int > &indices) const
Definition: VectorBase.h:431
VectorBase & elementwiseMultiplyFromLeftInPlace(const VectorBase< EE > &r)
Definition: VectorBase.h:340
(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:167
K::TInvert TInvert
Definition: CompositeNumericalTypes.h:157
MatrixView_< EHerm > updTranspose()
Definition: BigMatrix.h:230
EltResult< EE >::Mul rowScale(const VectorBase< EE > &v) const
Definition: VectorBase.h:172
VectorBase(MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
Construct a writable view into the source data.
Definition: VectorBase.h:117
аЯ рЁБ с ўџ З Й ўџџџ Г Д Е Ж џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџьЅС € ј П ч 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
VectorBase & resizeKeep(int m)
Definition: VectorBase.h:452
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
TNeg & updNegate()
Definition: VectorBase.h:446
VectorBase & elementwiseDivideInPlace(const VectorBase< EE > &r)
Definition: VectorBase.h:358
#define SimTK_THROW1(exc, a1)
Definition: Exception.h:311
void rowScale(const VectorBase< EE > &r, typename EltResult< EE >::Mul &out) const
Return type is a new matrix which will have the same dimensions as &#39;this&#39; but will have element types...
аЯ рЁБ с ўџ З Й ўџџџ Г Д Е Ж џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџьЅС € ј П ч 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 n a t u r a l n e s s
Definition: Simmatrix.doc:7
VectorView_< ELT > index(const Array_< int > &indices) const
Definition: VectorBase.h:420
VectorBase(int m, int stride, Scalar *s)
Construct a writable view into existing data.
Definition: VectorBase.h:104
int nrow() const
Definition: VectorBase.h:401
MatrixBase & elementwiseInvertInPlace()
Set M(i,j) = M(i,j)^-1.
Definition: BigMatrix.h:361
CNT< ScalarNormSq >::TSqrt weightedNormRMS(const VectorBase< EE > &w, int *worstOne=0) const
Return the weighted root-mean-square (WRMS) norm of a Vector of scalars, with optional return of the ...
Definition: VectorBase.h:216
This is the matrix class intended to appear in user code for large, variable size matrices...
Definition: BigMatrix.h:168
ELT & operator()(int i)
Definition: VectorBase.h:412
MatrixBase & operator+=(const MatrixBase &r)
Definition: MatrixBase.h:292
K::StdNumber StdNumber
Definition: CompositeNumericalTypes.h:163
const S * getElt(int i, int j) const
RowVectorBase< typename CNT< ELEM >::TAbs > abs(const RowVectorBase< ELEM > &v)
Definition: VectorMath.h:120
gјiЌтkDdёMV wfлaIJуtюц ЩAАйЉt”џ‡1Лƒ  J†љŠcA nrш “S qо is†І3 уЏ ЇжЇ Ы –ТгVфЦKф Cž ‰д9Z €У ЉD Ўq FxnЙцТ n єT ЉY Н‡< щ['ЖjdЛ< K JvTMЯH"ЋˆяОsђ™Ыw>}љіo_Йљ…Зo”ЖЃ?Ї zџШЎ'z:mЄІуЧV$ќКРŠyЁnаgЭ–џiлИ”J{и ž”хЩїTaК*АдdКВŽE|lєzƒbXс@!^Рклѕ‘гOЌoi_г=ўінOП}&ŒкХВQUŠŠ­V…ЅWT­shЃ!ГљPЌ_‰ŸЊЕС7šЅDR›AVъfЎ‘вЪПЈЛЅbOждЙЩЋtЎ0оY!О|л'ђЉx'žўУГ§нЅК—:/ўќПќ V[ц,тЇо}-Bжž§Ъ/ПјиџіЌм‚;у:Žх;яОй;IюЫПЇо˜й[nK4Ћ#ІЁ-Б='ЈGf€\lЙчѕœb41лЉŸ> ѓйOчsчЂ7x f p§€ъZ„‘zB рI •рƒЮ gЊБЁ Њ ˆ n
Definition: SimmathUserGuide.doc:2262
Specialized information about Composite Numerical Types which allows us to define appropriate templat...
Definition: CompositeNumericalTypes.h:136
TAbs abs() const
Definition: VectorBase.h:406
EAbs normInf(int *worstOne=0) const
Return the infinity norm (max absolute value) of a Vector of scalars, with optional return of the ind...
Definition: VectorBase.h:251
VectorBase(MatrixHelperRep< Scalar > *hrep)
Definition: VectorBase.h:467
VectorView_< ELT > operator()(int i, int m)
Definition: VectorBase.h:416
MatrixBase & operator=(const MatrixBase &b)
Definition: MatrixBase.h:201
const MatrixHelper< Scalar > & getHelper() const
Definition: MatrixBase.h:865
void rowScale(const VectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
Definition: VectorBase.h:170
VectorBase & operator=(const ELT &t)
Fill current allocation with copies of element.
Definition: VectorBase.h:162
void clear()
Definition: VectorBase.h:455
CNT< E >::TAbs EAbs
Definition: MatrixBase.h:84
This is a dataless rehash of the MatrixBase class to specialize it for Vectors.
Definition: BigMatrix.h:164
VectorBase(int m, int stride, const Scalar *s)
Construct a read-only view of existing data.
Definition: VectorBase.h:101
VectorIterator< ELT, VectorBase< ELT > > end()
Definition: VectorBase.h:461
VectorBase< EE >::template EltResult< ELT >::Dvd elementwiseDivideFromLeft(const VectorBase< EE > &v) const
Definition: VectorBase.h:376
const ELT & operator[](int i) const
Definition: VectorBase.h:409
A MatrixCommitment provides a set of acceptable matrix characteristics.
Definition: MatrixCharacteristics.h:832
const ELT & operator()(int i) const
Definition: VectorBase.h:411
THerm operator~() const
Definition: VectorBase.h:438
const VectorBase & operator+() const
Definition: VectorBase.h:441
ptrdiff_t nelt() const
Return the number of elements in the logical shape of this matrix.
Definition: MatrixBase.h:148
TAbs abs() const
abs() with the result as a function return.
Definition: MatrixBase.h:699
VectorBase & resize(int m)
Definition: VectorBase.h:451
K::Number Number
Definition: CompositeNumericalTypes.h:162
THerm transpose() const
Definition: VectorBase.h:435
EltResult< EE >::Dvd elementwiseDivide(const VectorBase< EE > &v) const
Definition: VectorBase.h:362
VectorBase & elementwiseInvertInPlace()
Set this[i] = this[i]^-1.
Definition: VectorBase.h:314
void clear()
This restores the MatrixBase to the state it would be in had it been constructed specifying only its ...
Definition: MatrixBase.h:288
VectorBase< typename CNT< ELT >::TInvert > elementwiseInvert() const
Return out[i]=this[i]^-1 as function return.
Definition: VectorBase.h:325
VectorBase< typename CNT< ELT >::template Result< P >::Sub > Sub
Definition: VectorBase.h:133
int ncol() const
Return the number of columns n in the logical shape of this matrix.
Definition: MatrixBase.h:139
MatrixBase & setTo(const ELT &t)
Fill every element in current allocation with given element (or NaN or 0).
Definition: MatrixBase.h:583
VectorBase(int m=0)
Default constructor makes a 0x1 matrix locked at 1 column; you can provide an initial allocation if y...
Definition: VectorBase.h:67
MatrixBase & resize(int m, int n)
Change the size of this matrix.
Definition: MatrixBase.h:774
VectorBase & elementwiseMultiplyInPlace(const VectorBase< EE > &r)
Definition: VectorBase.h:332
ELT & operator[](int i)
Definition: VectorBase.h:410
(Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:170
VectorBase & operator*=(const StdNumber &t)
Definition: VectorBase.h:145
void sum(S *eltp) const
Definition: VectorBase.h:129
void elementwiseInvert(VectorBase< typename CNT< ELT >::TInvert > &out) const
Set supplied out[i] = this[i]^-1.
Definition: VectorBase.h:320
ptrdiff_t nelt() const
Definition: VectorBase.h:403
VectorBase(int m, const ELT &initialValue)
Construct an owner vector of length m, with each element initialized to the given value...
Definition: VectorBase.h:79
CNT< ScalarNormSq >::TSqrt normRMS(int *worstOne=0) const
Return the root-mean-square (RMS) norm of a Vector of scalars, with optional return of the index of t...
Definition: VectorBase.h:180
const TNeg & negate() const
Definition: VectorBase.h:445
VectorBase(int m, const ELT *cppInitialValues)
Construct an owner vector of length m, with the elements initialized sequentially from a C++ array of...
Definition: VectorBase.h:86