fmatvec  0.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  static constexpr bool isVector {true};
46 
47  typedef AT* iterator;
48  typedef const AT* const_iterator;
49 
50  typedef AT value_type;
51 
53 
54  friend class Vector<Ref,AT>;
55 
56  protected:
57 
58  template<class Col> inline RowVector<Ref,AT>& copy(const RowVector<Col,AT> &x);
59 
60  const AT* elePtr(int i) const {
61  return ele+lda*i;
62  }
63 
64  AT* elePtr(int i) {
65  return ele+lda*i;
66  }
67 
69 
70  public:
71 
76  explicit RowVector() : Matrix<General,Ref,Ref,AT>() { m=1; }
77 
78  explicit RowVector(int n, Noinit ini) : Matrix<General,Ref,Ref,AT>(1,n,ini) { }
79  explicit RowVector(int n, Init ini=INIT, const AT &a=AT()) : Matrix<General,Ref,Ref,AT>(1,n,ini,a) { }
80 
87  }
88 
89  template<class Row>
90  RowVector(const RowVector<Row,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
91  }
92 
93  template<class Type, class Row, class Col>
94  explicit RowVector(const Matrix<Type,Row,Col,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
95  FMATVEC_ASSERT(x.rows()==1, AT);
96  }
97 
104  explicit RowVector(int n, AT* ele) : Matrix<General,Ref,Ref,AT>(1,n,ele) {
105  }
106 
119  RowVector(const char *str) : Matrix<General,Ref,Ref,AT>(str) {
120  FMATVEC_ASSERT(m==1, AT);
121  }
122 
123  RowVector<Ref,AT>& resize(int n, Noinit) {
125  return *this;
126  }
127 
128  RowVector<Ref,AT>& resize(int n, Init ini=INIT, const AT &a=AT()) {
129  Matrix<General,Ref,Ref,AT>::resize(1,n,ini,a);
130  return *this;
131  }
132 
140  FMATVEC_ASSERT(n == x.size(), AT);
141  return copy(x);
142  }
143 
150  template <class Row>
152  FMATVEC_ASSERT(n == x.size(), AT);
153  return copy(x);
154  }
155 
163  m = 1;
164  n = x.n;
165  memory = x.memory;
166  ele = x.ele;
167  lda = x.lda;
168  return *this;
169  }
170 
178  FMATVEC_ASSERT(A.rows() == 1, AT);
179  m = 1;
180  n = A.cols();
181  memory = A.memory;
182  ele = A.ele;
183  lda = A.lda;
184  return *this;
185  }
186 
193  template <class Row>
194  inline RowVector<Ref,AT>& operator<<=(const RowVector<Row,AT> &x) {
195  if(n!=x.size()) resize(x.size(),NONINIT);
196  return copy(x);
197  }
198 
199  template <class AT2>
200  operator Vector<Ref,AT2>() const {
201  Vector<Ref,AT2> ret(size());
202  for(size_t i=0; i<size(); ++i)
203  ret(i) = (*this)(i);
204  return ret;
205  }
206 
215  AT& operator()(int i) {
216  FMATVEC_ASSERT(i>=0, AT);
217  FMATVEC_ASSERT(i<n, AT);
218  return e(i);
219  }
220 
225  const AT& operator()(int i) const {
226  FMATVEC_ASSERT(i>=0, AT);
227  FMATVEC_ASSERT(i<n, AT);
228  return e(i);
229  }
230 
231  iterator begin() { FMATVEC_ASSERT(lda==1, AT); return &ele[0]; }
232  iterator end() { FMATVEC_ASSERT(lda==1, AT); return &ele[n*lda]; }
233  const_iterator begin() const { FMATVEC_ASSERT(lda==1, AT); return &ele[0]; }
234  const_iterator end() const { FMATVEC_ASSERT(lda==1, AT); return &ele[n*lda]; }
235  const_iterator cbegin() const noexcept { FMATVEC_ASSERT(lda==1, AT); return &ele[0]; }
236  const_iterator cend() const noexcept { FMATVEC_ASSERT(lda==1, AT); return &ele[n*lda]; }
237 
238  AT& e(int i) {
239  return ele[i*lda];
240  }
241 
242  const AT& e(int i) const {
243  return ele[i*lda];
244  }
245 
253  inline RowVector<Ref,AT>& init(const AT& val);
254  inline RowVector<Ref,AT>& init(Init, const AT &a=AT()) { return init(a); }
255  inline RowVector<Ref,AT>& init(Noinit, const AT &a=AT()) { return *this; }
256 
261  int size() const {return n;}
262 
269  int inc() const {return lda;}
270 
273  inline const RowVector<Ref,AT> operator()(const Range<Var,Var> &I) const;
274 
276 
277 // /*! \brief Cast to AT.
278 // *
279 // * \return The AT representation of the vector
280 // * */
281 // explicit operator AT() const {
282 // FMATVEC_ASSERT(n==1, AT);
283 // return e(0);
284 // }
285 //
286 // /*! \brief AT Constructor.
287 // * Constructs and initializes a vector with a AT object.
288 // * \param x The AT the vector will be initialized with.
289 // * */
290 // explicit RowVector(const AT &x) : Matrix<General,Ref,Ref,AT>(x) { }
291 
292  template<class Row> inline void set(const fmatvec::Range<Var,Var> &I, const RowVector<Row,AT> &x);
293 
294  template<class Row> inline void add(const fmatvec::Range<Var,Var> &I, const RowVector<Row,AT> &x);
295 
296  inline void ref(RowVector<Ref,AT> &x, const fmatvec::Range<Var,Var> &I);
297 
298  inline void ref(Matrix<General,Ref,Ref,AT> &A, int i);
299 
300  inline void ref(Matrix<General,Ref,Ref,AT> &A, int i, const fmatvec::Range<Var,Var> &J);
301 
302  const Vector<Ref,AT> T() const;
303  };
304 
306 
307  template <class AT>
309  for(int i=0; i<n; i++)
310  ele[i*lda] = val;
311  return *this;
312  }
313 
314  template <class AT>
316 
317  FMATVEC_ASSERT(I.end()<n, AT);
318  RowVector<Ref,AT> x(I.end()-I.start()+1,NONINIT);
319 
320  for(int i=0; i<x.size(); i++)
321  x.e(i) = e(I.start()+i);
322 
323  return x;
324  }
325 
327 
328  template <class AT> template <class Col>
330  for(int i=0; i<size(); i++)
331  e(i) = x.e(i);
332  return *this;
333  }
334 
335  template <class AT> template <class Row>
336  inline void RowVector<Ref,AT>::set(const Range<Var,Var> &I, const RowVector<Row,AT> &x) {
337 
338  FMATVEC_ASSERT(I.end()<size(), AT);
339  FMATVEC_ASSERT(I.size()==x.size(), AT);
340 
341  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
342  e(i) = x.e(ii);
343  }
344 
345  template <class AT> template <class Row>
346 
347  inline void RowVector<Ref,AT>::add(const Range<Var,Var> &I, const RowVector<Row,AT> &x) {
348  FMATVEC_ASSERT(I.end()<size(), AT);
349  FMATVEC_ASSERT(I.size()==x.size(), AT);
350 
351  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
352  e(i) += x.e(ii);
353  }
354 
355  template <class AT>
356  inline void RowVector<Ref,AT>::ref(RowVector<Ref,AT> &x, const fmatvec::Range<Var,Var> &I) {
357 
358  FMATVEC_ASSERT(I.end()<x.size(), AT);
359 
360  m=1;
361  n=I.size();
362  memory = x.memory;
363  ele = x.elePtr(I.start());
364  lda = x.lda;
365  }
366 
367  template <class AT>
368  inline void RowVector<Ref,AT>::ref(Matrix<General,Ref,Ref,AT> &A, int i) {
369 
370  FMATVEC_ASSERT(i<A.rows(), AT);
371 
372  m=1;
373  n=A.cols();
374  memory = A.memory;
375  ele = A.elePtr(i,0);
376  lda = A.lda;
377  }
378 
379  template <class AT>
380  inline void RowVector<Ref,AT>::ref(Matrix<General,Ref,Ref,AT> &A, int i, const fmatvec::Range<Var,Var> &J) {
381 
382  FMATVEC_ASSERT(i<A.rows(), AT);
383  FMATVEC_ASSERT(J.end()<A.cols(), AT);
384 
385  m=1;
386  n=J.size();
387  memory = A.memory;
388  ele = A.elePtr(i,J.start());
389  lda = A.lda;
390  }
391 
392  template <class AT>
393  inline const Vector<Ref,AT> RowVector<Ref,AT>::T() const {
394  Vector<Ref,AT> x(n,NONINIT);
395  for(int i=0; i<n; i++)
396  x.e(i) = e(i);
397  return x;
398  }
399 
401 
402 }
403 
404 #endif
int end() const
Last element.
Definition: range.h:91
AT & operator()(int i)
Element operator.
Definition: row_vector.h:215
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:304
RowVector(int n, AT *ele)
Regular Constructor.
Definition: row_vector.h:104
RowVector< Ref, AT > & operator=(const RowVector< Row, AT > &x)
Assignment operator.
Definition: row_vector.h:151
Definition: fmatvec.h:50
const AT & operator()(int i) const
Element operator.
Definition: row_vector.h:225
int size() const
Size.
Definition: row_vector.h:261
Definition: types.h:94
int inc() const
Increment.
Definition: row_vector.h:269
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:86
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:310
RowVector(const char *str)
String Constructor.
Definition: row_vector.h:119
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:139
RowVector()
Standard constructor.
Definition: row_vector.h:76
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:177
RowVector< Ref, AT > & operator&=(RowVector< Ref, AT > &x)
Reference operator.
Definition: row_vector.h:162