Simbody  3.5
RowVectorBase.h
Go to the documentation of this file.
1 #ifndef SimTK_SIMMATRIX_ROWVECTORBASE_H_
2 #define SimTK_SIMMATRIX_ROWVECTORBASE_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 // ROW VECTOR BASE
35 //==============================================================================
42 template <class ELT> class RowVectorBase : public MatrixBase<ELT> {
43  typedef MatrixBase<ELT> Base;
44  typedef typename CNT<ELT>::Scalar Scalar;
45  typedef typename CNT<ELT>::Number Number;
46  typedef typename CNT<ELT>::StdNumber StdNumber;
47  typedef RowVectorBase<ELT> T;
48  typedef RowVectorBase<typename CNT<ELT>::TAbs> TAbs;
49  typedef RowVectorBase<typename CNT<ELT>::TNeg> TNeg;
50  typedef VectorView_<typename CNT<ELT>::THerm> THerm;
51 public:
52  // ------------------------------------------------------------------------
62 
65  explicit RowVectorBase(int n=0) : Base(MatrixCommitment::RowVector(), 1, n) {}
66 
70  RowVectorBase(const RowVectorBase& source) : Base(source) {}
71 
73  RowVectorBase(const TNeg& source) : Base(source) {}
74 
77  RowVectorBase(int n, const ELT& initialValue)
78  : Base(MatrixCommitment::RowVector(),1,n,initialValue) {}
79 
84  RowVectorBase(int n, const ELT* cppInitialValues)
85  : Base(MatrixCommitment::RowVector(),1,n,cppInitialValues) {}
87 
88  // ------------------------------------------------------------------------
97 
99  RowVectorBase(int n, int stride, const Scalar* s)
100  : Base(MatrixCommitment::RowVector(n), MatrixCharacter::RowVector(n),stride,s) { }
102  RowVectorBase(int n, int stride, Scalar* s)
103  : Base(MatrixCommitment::RowVector(n), MatrixCharacter::RowVector(n),stride,s) { }
105 
106  // ------------------------------------------------------------------------
113 
116  : Base(MatrixCommitment::RowVector(), h,s) { }
119  : Base(MatrixCommitment::RowVector(), h,s) { }
122  : Base(MatrixCommitment::RowVector(), h,d) { }
124 
125  // This gives the resulting rowvector type when (r(i) op P) is applied to each element.
126  // It will have element types which are the regular composite result of ELT op P.
127  template <class P> struct EltResult {
132  };
133 
137  Base::operator=(b); return *this;
138  }
139 
140  // default destructor
141 
142  RowVectorBase& operator*=(const StdNumber& t) {Base::operator*=(t); return *this;}
143  RowVectorBase& operator/=(const StdNumber& t) {Base::operator/=(t); return *this;}
146 
147  template <class EE> RowVectorBase& operator=(const RowVectorBase<EE>& b)
148  { Base::operator=(b); return *this; }
149  template <class EE> RowVectorBase& operator+=(const RowVectorBase<EE>& b)
150  { Base::operator+=(b); return *this; }
151  template <class EE> RowVectorBase& operator-=(const RowVectorBase<EE>& b)
152  { Base::operator-=(b); return *this; }
153 
154  // default destructor
155 
159  RowVectorBase& operator=(const ELT& t) { Base::setTo(t); return *this; }
160 
165  template <class EE> RowVectorBase& colScaleInPlace(const VectorBase<EE>& v)
166  { Base::template colScaleInPlace<EE>(v); return *this; }
167  template <class EE> inline void colScale(const VectorBase<EE>& v, typename EltResult<EE>::Mul& out) const
168  { return Base::template colScale<EE>(v,out); }
169  template <class EE> inline typename EltResult<EE>::Mul colScale(const VectorBase<EE>& v) const
170  { typename EltResult<EE>::Mul out(ncol()); Base::template colScale<EE>(v,out); return out; }
171 
172 
173  // elementwise multiply
175  { Base::template elementwiseMultiplyInPlace<EE>(r); return *this; }
176  template <class EE> inline void elementwiseMultiply(const RowVectorBase<EE>& v, typename EltResult<EE>::Mul& out) const
177  { Base::template elementwiseMultiply<EE>(v,out); }
178  template <class EE> inline typename EltResult<EE>::Mul elementwiseMultiply(const RowVectorBase<EE>& v) const
179  { typename EltResult<EE>::Mul out(nrow()); Base::template elementwiseMultiply<EE>(v,out); return out; }
180 
181  // elementwise multiply from left
183  { Base::template elementwiseMultiplyFromLeftInPlace<EE>(r); return *this; }
184  template <class EE> inline void
186  const RowVectorBase<EE>& v,
188  {
189  Base::template elementwiseMultiplyFromLeft<EE>(v,out);
190  }
191  template <class EE> inline
195  Base::template elementwiseMultiplyFromLeft<EE>(v,out);
196  return out;
197  }
198 
199  // elementwise divide
201  { Base::template elementwiseDivideInPlace<EE>(r); return *this; }
202  template <class EE> inline void elementwiseDivide(const RowVectorBase<EE>& v, typename EltResult<EE>::Dvd& out) const
203  { Base::template elementwiseDivide<EE>(v,out); }
204  template <class EE> inline typename EltResult<EE>::Dvd elementwiseDivide(const RowVectorBase<EE>& v) const
205  { typename EltResult<EE>::Dvd out(nrow()); Base::template elementwiseDivide<EE>(v,out); return out; }
206 
207  // elementwise divide from left
209  { Base::template elementwiseDivideFromLeftInPlace<EE>(r); return *this; }
210  template <class EE> inline void
212  (const RowVectorBase<EE>& v,
213  typename RowVectorBase<EE>::template EltResult<ELT>::Dvd& out) const {
214  Base::template elementwiseDivideFromLeft<EE>(v,out);
215  }
216  template <class EE> inline
220  Base::template elementwiseDivideFromLeft<EE>(v,out);
221  return out;
222  }
223 
224  // Implicit conversions are allowed to RowVector or Matrix, but not to Vector.
225  operator const RowVector_<ELT>&() const {return *reinterpret_cast<const RowVector_<ELT>*>(this);}
226  operator RowVector_<ELT>&() {return *reinterpret_cast< RowVector_<ELT>*>(this);}
227  operator const RowVectorView_<ELT>&() const {return *reinterpret_cast<const RowVectorView_<ELT>*>(this);}
228  operator RowVectorView_<ELT>&() {return *reinterpret_cast< RowVectorView_<ELT>*>(this);}
229 
230  operator const Matrix_<ELT>&() const {return *reinterpret_cast<const Matrix_<ELT>*>(this);}
231  operator Matrix_<ELT>&() {return *reinterpret_cast< Matrix_<ELT>*>(this);}
232  operator const MatrixView_<ELT>&() const {return *reinterpret_cast<const MatrixView_<ELT>*>(this);}
233  operator MatrixView_<ELT>&() {return *reinterpret_cast< MatrixView_<ELT>*>(this);}
234 
235 
236  // size() for RowVectors is Base::nelt() but returns int instead of ptrdiff_t.
237  int size() const {
238  assert(Base::nelt() <= (ptrdiff_t)std::numeric_limits<int>::max());
239  assert(Base::nrow()==1);
240  return (int)Base::nelt();
241  }
242  int nrow() const {assert(Base::nrow()==1); return Base::nrow();}
243  int ncol() const {assert(Base::nrow()==1); return Base::ncol();}
244  ptrdiff_t nelt() const {assert(Base::nrow()==1); return Base::nelt();}
245 
246  // Override MatrixBase operators to return the right shape
247  TAbs abs() const {
248  TAbs result; Base::abs(result); return result;
249  }
250 
251  // Override MatrixBase indexing operators
252  const ELT& operator[](int j) const {return *reinterpret_cast<const ELT*>(Base::getHelper().getElt(j));}
253  ELT& operator[](int j) {return *reinterpret_cast<ELT*> (Base::updHelper().updElt(j));}
254  const ELT& operator()(int j) const {return *reinterpret_cast<const ELT*>(Base::getHelper().getElt(j));}
255  ELT& operator()(int j) {return *reinterpret_cast<ELT*> (Base::updHelper().updElt(j));}
256 
257  // Block (contiguous subvector) creation
258  RowVectorView_<ELT> operator()(int j, int n) const {return Base::operator()(0,j,1,n).getAsRowVectorView();}
259  RowVectorView_<ELT> operator()(int j, int n) {return Base::operator()(0,j,1,n).updAsRowVectorView();}
260 
261  // Indexed view creation (arbitrary subvector). Indices must be monotonically increasing.
262  RowVectorView_<ELT> index(const Array_<int>& indices) const {
264  return RowVectorView_<ELT>(h);
265  }
268  return RowVectorView_<ELT>(h);
269  }
270 
271  RowVectorView_<ELT> operator()(const Array_<int>& indices) const {return index(indices);}
272  RowVectorView_<ELT> operator()(const Array_<int>& indices) {return updIndex(indices);}
273 
274  // Hermitian transpose.
275  THerm transpose() const {return Base::transpose().getAsVectorView();}
276  THerm updTranspose() {return Base::updTranspose().updAsVectorView();}
277 
278  THerm operator~() const {return transpose();}
279  THerm operator~() {return updTranspose();}
280 
281  const RowVectorBase& operator+() const {return *this; }
282 
283  // Negation
284 
285  const TNeg& negate() const {return *reinterpret_cast<const TNeg*>(this); }
286  TNeg& updNegate() {return *reinterpret_cast<TNeg*>(this); }
287 
288  const TNeg& operator-() const {return negate();}
289  TNeg& operator-() {return updNegate();}
290 
291  RowVectorBase& resize(int n) {Base::resize(1,n); return *this;}
292  RowVectorBase& resizeKeep(int n) {Base::resizeKeep(1,n); return *this;}
293 
294  //TODO: this is not re-locking the number of rows at 1.
295  void clear() {Base::clear(); Base::resize(1,0);}
296 
297  ELT sum() const {ELT s; Base::getHelper().sum(reinterpret_cast<Scalar*>(&s)); return s; } // add all the elements
299  return VectorIterator<ELT, RowVectorBase<ELT> >(*this, 0);
300  }
302  return VectorIterator<ELT, RowVectorBase<ELT> >(*this, size());
303  }
304 
305 protected:
306  // Create a RowVectorBase handle using a given helper rep.
307  explicit RowVectorBase(MatrixHelperRep<Scalar>* hrep) : Base(hrep) {}
308 
309 private:
310  // NO DATA MEMBERS ALLOWED
311 };
312 
313 } //namespace SimTK
314 
315 #endif // SimTK_SIMMATRIX_ROWVECTORBASE_H_
VectorView_< ELT > operator()(int j) const
Definition: MatrixBase.h:595
RowVectorBase(int n=0)
Default constructor makes a 1x0 matrix locked at 1 row; you can provide an initial allocation if you ...
Definition: RowVectorBase.h:65
RowVectorBase & operator+=(const RowVectorBase< EE > &b)
Definition: RowVectorBase.h:149
EltResult< EE >::Dvd elementwiseDivide(const RowVectorBase< EE > &v) const
Definition: RowVectorBase.h:204
RowVectorBase & elementwiseMultiplyFromLeftInPlace(const RowVectorBase< EE > &r)
Definition: RowVectorBase.h:182
void elementwiseDivide(const RowVectorBase< EE > &v, typename EltResult< EE >::Dvd &out) const
Definition: RowVectorBase.h:202
void clear()
Definition: RowVectorBase.h:295
RowVectorBase(const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
Construct a read-only view of the source data.
Definition: RowVectorBase.h:118
RowVectorView_< ELT > operator()(int j, int n) const
Definition: RowVectorBase.h:258
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
RowVectorBase(const TNeg &source)
Implicit conversion from compatible row vector with negated elements.
Definition: RowVectorBase.h:73
This is a dataless rehash of the MatrixBase class to specialize it for RowVectors.
Definition: BigMatrix.h:165
const MatrixCommitment & getCharacterCommitment() const
Definition: MatrixBase.h:119
RowVectorView_< ELT > operator()(int j, int n)
Definition: RowVectorBase.h:259
RowVectorBase< EE >::template EltResult< ELT >::Dvd elementwiseDivideFromLeft(const RowVectorBase< EE > &v) const
Definition: RowVectorBase.h:218
RowVectorBase< EE >::template EltResult< ELT >::Mul elementwiseMultiplyFromLeft(const RowVectorBase< EE > &v) const
Definition: RowVectorBase.h:193
void elementwiseMultiplyFromLeft(const RowVectorBase< EE > &v, typename RowVectorBase< EE >::template EltResult< ELT >::Mul &out) const
Definition: RowVectorBase.h:185
RowVectorBase & operator=(const ELT &t)
Fill current allocation with copies of element.
Definition: RowVectorBase.h:159
THerm operator~() const
Definition: RowVectorBase.h:278
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
MatrixHelper< Scalar > & updHelper()
Definition: MatrixBase.h:866
THerm operator~()
Definition: RowVectorBase.h:279
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
void colScale(const VectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
Definition: RowVectorBase.h:167
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
RowVectorBase(MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::ShallowCopy &s)
Construct a writable view into the source data.
Definition: RowVectorBase.h:115
EltResult< EE >::Mul elementwiseMultiply(const RowVectorBase< EE > &v) const
Definition: RowVectorBase.h:178
RowVectorBase & operator-=(const RowVectorBase &r)
Definition: RowVectorBase.h:145
THerm transpose() const
Definition: RowVectorBase.h:275
MatrixBase & operator-=(const MatrixBase &r)
Definition: MatrixBase.h:293
MatrixBase & operator*=(const StdNumber &t)
Definition: MatrixBase.h:290
S * updElt(int i, int j)
RowVectorBase & operator+=(const RowVectorBase &r)
Definition: RowVectorBase.h:144
ELT & operator()(int j)
Definition: RowVectorBase.h:255
Definition: RowVectorBase.h:127
RowVectorBase & operator=(const RowVectorBase< EE > &b)
Definition: RowVectorBase.h:147
(Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assi...
Definition: BigMatrix.h:173
RowVectorBase(const RowVectorBase &source)
Copy constructor is a deep copy (not appropriate for views!).
Definition: RowVectorBase.h:70
const TNeg & operator-() const
Definition: RowVectorBase.h:288
RowVectorBase(int n, const ELT &initialValue)
Construct an owner row vector of length n, with each element initialized to the given value...
Definition: RowVectorBase.h:77
MatrixView_< EHerm > transpose() const
Definition: BigMatrix.h:222
This is an iterator for iterating over the elements of a Vector_ or Vec object.
Definition: BigMatrix.h:176
int nrow() const
Return the number of rows m in the logical shape of this matrix.
Definition: MatrixBase.h:137
RowVectorBase(MatrixHelperRep< Scalar > *hrep)
Definition: RowVectorBase.h:307
RowVectorBase & elementwiseMultiplyInPlace(const RowVectorBase< EE > &r)
Definition: RowVectorBase.h:174
(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:167
RowVectorBase< typename CNT< ELT >::template Result< P >::Sub > Sub
Definition: RowVectorBase.h:131
RowVectorBase< typename CNT< ELT >::template Result< P >::Mul > Mul
Definition: RowVectorBase.h:128
const ELT & operator[](int j) const
Definition: RowVectorBase.h:252
MatrixView_< EHerm > updTranspose()
Definition: BigMatrix.h:230
RowVectorView_< ELT > updIndex(const Array_< int > &indices)
Definition: RowVectorBase.h:266
EltResult< EE >::Mul colScale(const VectorBase< EE > &v) const
Definition: RowVectorBase.h:169
аЯ рЁБ с ўџ З Й ўџџџ Г Д Е Ж џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџьЅС € ј П ч 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
TNeg & operator-()
Definition: RowVectorBase.h:289
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
RowVectorBase< typename CNT< ELT >::template Result< P >::Dvd > Dvd
Definition: RowVectorBase.h:129
RowVectorBase & colScaleInPlace(const VectorBase< EE > &v)
There&#39;s only one row here so it&#39;s a bit wierd to use colScale rather than elementwiseMultiply, but there&#39;s nothing really wrong with it.
Definition: RowVectorBase.h:165
RowVectorBase & operator-=(const RowVectorBase< EE > &b)
Definition: RowVectorBase.h:151
RowVectorBase & resize(int n)
Definition: RowVectorBase.h:291
VectorIterator< ELT, RowVectorBase< ELT > > begin()
Definition: RowVectorBase.h:298
аЯ рЁБ с ўџ З Й ўџџџ Г Д Е Ж џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџьЅС € ј П ч 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
VectorIterator< ELT, RowVectorBase< ELT > > end()
Definition: RowVectorBase.h:301
RowVectorBase & elementwiseDivideInPlace(const RowVectorBase< EE > &r)
Definition: RowVectorBase.h:200
int nrow() const
Definition: RowVectorBase.h:242
const RowVectorBase & operator+() const
Definition: RowVectorBase.h:281
RowVectorBase & elementwiseDivideFromLeftInPlace(const RowVectorBase< EE > &r)
Definition: RowVectorBase.h:208
RowVectorBase & operator/=(const StdNumber &t)
Definition: RowVectorBase.h:143
int size() const
Definition: RowVectorBase.h:237
This is the matrix class intended to appear in user code for large, variable size matrices...
Definition: BigMatrix.h:168
RowVectorBase & operator=(const RowVectorBase &b)
Copy assignment is deep copy but behavior depends on type of lhs: if view, rhs must match...
Definition: RowVectorBase.h:136
RowVectorView_< ELT > index(const Array_< int > &indices) const
Definition: RowVectorBase.h:262
MatrixBase & operator+=(const MatrixBase &r)
Definition: MatrixBase.h:292
K::StdNumber StdNumber
Definition: CompositeNumericalTypes.h:163
const S * getElt(int i, int j) const
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
THerm updTranspose()
Definition: RowVectorBase.h:276
RowVectorBase(int n, int stride, Scalar *s)
Construct a writable view into existing data.
Definition: RowVectorBase.h:102
MatrixBase & operator=(const MatrixBase &b)
Definition: MatrixBase.h:201
const MatrixHelper< Scalar > & getHelper() const
Definition: MatrixBase.h:865
ELT & operator[](int j)
Definition: RowVectorBase.h:253
This is a dataless rehash of the MatrixBase class to specialize it for Vectors.
Definition: BigMatrix.h:164
void elementwiseMultiply(const RowVectorBase< EE > &v, typename EltResult< EE >::Mul &out) const
Definition: RowVectorBase.h:176
RowVectorBase(int n, int stride, const Scalar *s)
Construct a read-only view of existing data.
Definition: RowVectorBase.h:99
Represents a variable size row vector; much less common than the column vector type Vector_...
Definition: BigMatrix.h:174
A MatrixCommitment provides a set of acceptable matrix characteristics.
Definition: MatrixCharacteristics.h:832
RowVectorBase(const MatrixHelper< Scalar > &h, const typename MatrixHelper< Scalar >::DeepCopy &d)
Construct a new owner vector initialized with the data from the source.
Definition: RowVectorBase.h:121
ELT sum() const
Definition: RowVectorBase.h:297
const ELT & operator()(int j) const
Definition: RowVectorBase.h:254
void elementwiseDivideFromLeft(const RowVectorBase< EE > &v, typename RowVectorBase< EE >::template EltResult< ELT >::Dvd &out) const
Definition: RowVectorBase.h:212
RowVectorView_< ELT > operator()(const Array_< int > &indices) const
Definition: RowVectorBase.h:271
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
K::Number Number
Definition: CompositeNumericalTypes.h:162
int ncol() const
Definition: RowVectorBase.h:243
ptrdiff_t nelt() const
Definition: RowVectorBase.h:244
void clear()
This restores the MatrixBase to the state it would be in had it been constructed specifying only its ...
Definition: MatrixBase.h:288
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
RowVectorBase & operator*=(const StdNumber &t)
Definition: RowVectorBase.h:142
RowVectorBase & resizeKeep(int n)
Definition: RowVectorBase.h:292
MatrixBase & resize(int m, int n)
Change the size of this matrix.
Definition: MatrixBase.h:774
RowVectorBase(int n, const ELT *cppInitialValues)
Construct an owner vector of length n, with the elements initialized sequentially from a C++ array of...
Definition: RowVectorBase.h:84
const TNeg & negate() const
Definition: RowVectorBase.h:285
void sum(S *eltp) const
RowVectorView_< ELT > operator()(const Array_< int > &indices)
Definition: RowVectorBase.h:272
RowVectorBase< typename CNT< ELT >::template Result< P >::Add > Add
Definition: RowVectorBase.h:130
TNeg & updNegate()
Definition: RowVectorBase.h:286
TAbs abs() const
Definition: RowVectorBase.h:247