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
332  template <class EE> VectorBase& elementwiseMultiplyInPlace(const VectorBase<EE>& r)
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
358  template <class EE> VectorBase& elementwiseDivideInPlace(const VectorBase<EE>& r)
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
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
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
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...
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
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