fmatvec  2.0.0
Fast Matrix/Vector Library
row_vector.h
1 /* Copyright (C) 2003-2005 Martin Förg
2 
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16  *
17  * Contact:
18  * martin.o.foerg@googlemail.com
19  *
20  */
21 
22 #ifndef row_vector_h
23 #define row_vector_h
24 
25 #include "general_matrix.h"
26 
27 namespace fmatvec {
36  template <class AT> class RowVector<Ref,AT> : public Matrix<General,Ref,Ref,AT> {
43 
44  public:
45 
46  typedef AT* iterator;
47  typedef const AT* const_iterator;
48 
49  typedef AT value_type;
50 
52 
53  friend class Vector<Ref,AT>;
54 
55  protected:
56 
57  template<class Col> inline RowVector<Ref,AT>& copy(const RowVector<Col,AT> &x);
58 
59  const AT* elePtr(int i) const {
60  return ele+lda*i;
61  }
62 
63  AT* elePtr(int i) {
64  return ele+lda*i;
65  }
66 
68 
69  public:
70 
75  explicit RowVector() : Matrix<General,Ref,Ref,AT>() { m=1; }
76 
77  explicit RowVector(int n, Noinit ini) : Matrix<General,Ref,Ref,AT>(1,n,ini) { }
78  explicit RowVector(int n, Init ini=INIT, const AT &a=AT()) : Matrix<General,Ref,Ref,AT>(1,n,ini,a) { }
79 
86  }
87 
88  template<class Row>
89  RowVector(const RowVector<Row,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
90  }
91 
92  template<class Type, class Row, class Col>
93  explicit RowVector(const Matrix<Type,Row,Col,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
94  FMATVEC_ASSERT(x.rows()==1, AT);
95  }
96 
103  explicit RowVector(int n, AT* ele) : Matrix<General,Ref,Ref,AT>(1,n,ele) {
104  }
105 
118  RowVector(const char *str) : Matrix<General,Ref,Ref,AT>(str) {
119  FMATVEC_ASSERT(m==1, AT);
120  }
121 
122  RowVector<Ref,AT>& resize(int n, Noinit) {
124  return *this;
125  }
126 
127  RowVector<Ref,AT>& resize(int n, Init ini=INIT, const AT &a=AT()) {
128  Matrix<General,Ref,Ref,AT>::resize(1,n,ini,a);
129  return *this;
130  }
131 
139  FMATVEC_ASSERT(n == x.size(), AT);
140  return copy(x);
141  }
142 
149  template <class Row>
151  FMATVEC_ASSERT(n == x.size(), AT);
152  return copy(x);
153  }
154 
162  m = 1;
163  n = x.n;
164  memory = x.memory;
165  ele = x.ele;
166  lda = x.lda;
167  return *this;
168  }
169 
177  FMATVEC_ASSERT(A.rows() == 1, AT);
178  m = 1;
179  n = A.cols();
180  memory = A.memory;
181  ele = A.ele;
182  lda = A.lda;
183  return *this;
184  }
185 
192  template <class Row>
193  inline RowVector<Ref,AT>& operator<<=(const RowVector<Row,AT> &x) {
194  if(n!=x.size()) resize(x.size(),NONINIT);
195  return copy(x);
196  }
197 
198  template <class AT2>
199  operator Vector<Ref,AT2>() const {
200  Vector<Ref,AT2> ret(size());
201  for(size_t i=0; i<size(); ++i)
202  ret(i) = (*this)(i);
203  return ret;
204  }
205 
214  AT& operator()(int i) {
215  FMATVEC_ASSERT(i>=0, AT);
216  FMATVEC_ASSERT(i<n, AT);
217  return e(i);
218  }
219 
224  const AT& operator()(int i) const {
225  FMATVEC_ASSERT(i>=0, AT);
226  FMATVEC_ASSERT(i<n, AT);
227  return e(i);
228  }
229 
230  iterator begin() { FMATVEC_ASSERT(lda==1, AT); return &ele[0]; }
231  iterator end() { FMATVEC_ASSERT(lda==1, AT); return &ele[n*lda]; }
232  const_iterator begin() const { FMATVEC_ASSERT(lda==1, AT); return &ele[0]; }
233  const_iterator end() const { FMATVEC_ASSERT(lda==1, AT); return &ele[n*lda]; }
234  const_iterator cbegin() const noexcept { FMATVEC_ASSERT(lda==1, AT); return &ele[0]; }
235  const_iterator cend() const noexcept { FMATVEC_ASSERT(lda==1, AT); return &ele[n*lda]; }
236 
237  AT& e(int i) {
238  return ele[i*lda];
239  }
240 
241  const AT& e(int i) const {
242  return ele[i*lda];
243  }
244 
252  inline RowVector<Ref,AT>& init(const AT& val);
253  inline RowVector<Ref,AT>& init(Init, const AT &a=AT()) { return init(a); }
254  inline RowVector<Ref,AT>& init(Noinit, const AT &a=AT()) { return *this; }
255 
260  int size() const {return n;}
261 
268  int inc() const {return lda;}
269 
272  inline const RowVector<Ref,AT> operator()(const Range<Var,Var> &I) const;
273 
275 
276 // /*! \brief Cast to AT.
277 // *
278 // * \return The AT representation of the vector
279 // * */
280 // explicit operator AT() const {
281 // FMATVEC_ASSERT(n==1, AT);
282 // return e(0);
283 // }
284 //
285 // /*! \brief AT Constructor.
286 // * Constructs and initializes a vector with a AT object.
287 // * \param x The AT the vector will be initialized with.
288 // * */
289 // explicit RowVector(const AT &x) : Matrix<General,Ref,Ref,AT>(x) { }
290 
291  template<class Row> inline void set(const fmatvec::Range<Var,Var> &I, const RowVector<Row,AT> &x);
292 
293  template<class Row> inline void add(const fmatvec::Range<Var,Var> &I, const RowVector<Row,AT> &x);
294 
295  inline void ref(RowVector<Ref,AT> &x, const fmatvec::Range<Var,Var> &I);
296 
297  inline void ref(Matrix<General,Ref,Ref,AT> &A, int i);
298 
299  inline void ref(Matrix<General,Ref,Ref,AT> &A, int i, const fmatvec::Range<Var,Var> &J);
300 
301  const Vector<Ref,AT> T() const;
302  };
303 
305 
306  template <class AT>
308  for(int i=0; i<n; i++)
309  ele[i*lda] = val;
310  return *this;
311  }
312 
313  template <class AT>
315 
316  FMATVEC_ASSERT(I.end()<n, AT);
317  RowVector<Ref,AT> x(I.end()-I.start()+1,NONINIT);
318 
319  for(int i=0; i<x.size(); i++)
320  x.e(i) = e(I.start()+i);
321 
322  return x;
323  }
324 
326 
327  template <class AT> template <class Col>
329  for(int i=0; i<size(); i++)
330  e(i) = x.e(i);
331  return *this;
332  }
333 
334  template <class AT> template <class Row>
335  inline void RowVector<Ref,AT>::set(const Range<Var,Var> &I, const RowVector<Row,AT> &x) {
336 
337  FMATVEC_ASSERT(I.end()<size(), AT);
338  FMATVEC_ASSERT(I.size()==x.size(), AT);
339 
340  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
341  e(i) = x.e(ii);
342  }
343 
344  template <class AT> template <class Row>
345 
346  inline void RowVector<Ref,AT>::add(const Range<Var,Var> &I, const RowVector<Row,AT> &x) {
347  FMATVEC_ASSERT(I.end()<size(), AT);
348  FMATVEC_ASSERT(I.size()==x.size(), AT);
349 
350  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
351  e(i) += x.e(ii);
352  }
353 
354  template <class AT>
355  inline void RowVector<Ref,AT>::ref(RowVector<Ref,AT> &x, const fmatvec::Range<Var,Var> &I) {
356 
357  FMATVEC_ASSERT(I.end()<x.size(), AT);
358 
359  m=1;
360  n=I.size();
361  memory = x.memory;
362  ele = x.elePtr(I.start());
363  lda = x.lda;
364  }
365 
366  template <class AT>
367  inline void RowVector<Ref,AT>::ref(Matrix<General,Ref,Ref,AT> &A, int i) {
368 
369  FMATVEC_ASSERT(i<A.rows(), AT);
370 
371  m=1;
372  n=A.cols();
373  memory = A.memory;
374  ele = A.elePtr(i,0);
375  lda = A.lda;
376  }
377 
378  template <class AT>
379  inline void RowVector<Ref,AT>::ref(Matrix<General,Ref,Ref,AT> &A, int i, const fmatvec::Range<Var,Var> &J) {
380 
381  FMATVEC_ASSERT(i<A.rows(), AT);
382  FMATVEC_ASSERT(J.end()<A.cols(), AT);
383 
384  m=1;
385  n=J.size();
386  memory = A.memory;
387  ele = A.elePtr(i,J.start());
388  lda = A.lda;
389  }
390 
391  template <class AT>
392  inline const Vector<Ref,AT> RowVector<Ref,AT>::T() const {
393  Vector<Ref,AT> x(n,NONINIT);
394  for(int i=0; i<n; i++)
395  x.e(i) = e(i);
396  return x;
397  }
398 
400 
401 }
402 
403 #endif
int end() const
Last element.
Definition: range.h:91
AT & operator()(int i)
Element operator.
Definition: row_vector.h:214
This is the basic matrix class for arbitrary matrices.
Definition: fmatvec.h:41
void set(const fmatvec::Range< Var, Var > &I, const RowVector< Row, AT > &x)
Cast to AT.
int rows() const
Number of rows.
Definition: general_matrix.h:278
RowVector(int n, AT *ele)
Regular Constructor.
Definition: row_vector.h:103
RowVector< Ref, AT > & operator=(const RowVector< Row, AT > &x)
Assignment operator.
Definition: row_vector.h:150
Definition: fmatvec.h:50
const AT & operator()(int i) const
Element operator.
Definition: row_vector.h:224
int size() const
Size.
Definition: row_vector.h:260
Definition: types.h:94
int inc() const
Increment.
Definition: row_vector.h:268
This is a rowvector class of general shape in dense storage format.
Definition: row_vector.h:36
int start() const
First element.
Definition: range.h:85
Definition: fmatvec.h:47
RowVector(const RowVector< Ref, AT > &x)
Copy Constructor.
Definition: row_vector.h:85
This is a matrix class for general matrices.
Definition: general_matrix.h:41
Namespace fmatvec.
Definition: _memory.cc:28
int cols() const
Number of columns.
Definition: general_matrix.h:284
RowVector(const char *str)
String Constructor.
Definition: row_vector.h:118
int size() const
Size.
Definition: range.h:97
Definition: types.h:84
Basic shape class for matrices.
Definition: types.h:132
This is a vector class of general shape in dense storage format.
Definition: vector.h:39
RowVector< Ref, AT > & operator=(const RowVector< Ref, AT > &x)
Assignment operator.
Definition: row_vector.h:138
RowVector()
Standard constructor.
Definition: row_vector.h:75
This is an index class for creating submatrices.
Definition: range.h:44
RowVector< Ref, AT > & operator&=(Matrix< General, Ref, Ref, AT > &A)
Reference operator.
Definition: row_vector.h:176
RowVector< Ref, AT > & operator&=(RowVector< Ref, AT > &x)
Reference operator.
Definition: row_vector.h:161