fmatvec  2.0.0
Fast Matrix/Vector Library
var_vector.h
1 /* Copyright (C) 2003-2012 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 var_vector_h
23 #define var_vector_h
24 
25 #include "var_general_matrix.h"
26 #include <vector>
27 #include <cstring>
28 
29 namespace fmatvec {
30 
39  template <class AT> class Vector<fmatvec::Var,AT> : public Matrix<fmatvec::General,fmatvec::Var,fmatvec::Fixed<1>,AT> {
40  using Matrix<General,Var,Fixed<1>,AT>::M;
41  using Matrix<General,Var,Fixed<1>,AT>::ele;
42 
43  public:
44 
45  typedef AT* iterator;
46  typedef const AT* const_iterator;
47 
48  typedef AT value_type;
49 
51 
52  protected:
53 
54  template<class Row> inline Vector<Var,AT>& copy(const Vector<Row,AT> &x);
55 
57 
58  public:
59 
64  explicit Vector() : Matrix<General,Var,Fixed<1>,AT>() { }
65 
66 // template<class Ini=All<AT>>
67 // Vector(int m, Ini ini=All<AT>()) : Matrix<General,Var,Fixed<1>,AT>(m,ini) { }
68 
69  explicit Vector(int m, Noinit ini) : Matrix<General,Var,Fixed<1>,AT>(m,ini) { }
70  explicit Vector(int m, Init ini=INIT, const AT &a=AT()) : Matrix<General,Var,Fixed<1>,AT>(m,ini,a) { }
71 
77  Vector(const Vector<Var,AT> &x) : Matrix<General,Var,Fixed<1>,AT>(x) {
78  }
79 
85  template<class Row>
86  Vector(const Vector<Row,AT> &A) : Matrix<General,Var,Fixed<1>,AT>(A) {
87  }
88 
94  template<class Type, class Row, class Col>
95  explicit Vector(const Matrix<Type,Row,Col,AT> &A) : Matrix<General,Var,Fixed<1>,AT>(A) {
96  }
97 
110  Vector(const char *str) : Matrix<General,Var,Fixed<1>,AT>(str) {
111  }
112 
113  Vector<Var,AT>& resize(int m, Noinit) {
114  Matrix<General,Var,Fixed<1>,AT>::resize(m,Noinit());
115  return *this;
116  }
117 
118  Vector<Var,AT>& resize(int m, Init ini=INIT, const AT &a=AT()) {
119  Matrix<General,Var,Fixed<1>,AT>::resize(m,ini,a);
120  return *this;
121  }
122 
130  FMATVEC_ASSERT(M == x.size(), AT);
131  return copy(x);
132  }
133 
140  template <class Row>
142  FMATVEC_ASSERT(M == x.size(), AT);
143  return copy(x);
144  }
145 
152  template <class Row>
153  inline Vector<Var,AT>& operator<<=(const Vector<Row,AT> &x) {
154  if(M!=x.size()) resize(x.size(),NONINIT);
155  return copy(x);
156  }
157 
158  template <class AT2>
159  operator Vector<Var,AT2>() const {
160  Vector<Var,AT2> ret(size());
161  for(size_t i=0; i<size(); ++i)
162  ret(i) = (*this)(i);
163  return ret;
164  }
165 
174  AT& operator()(int i) {
175 
176  FMATVEC_ASSERT(i>=0, AT);
177  FMATVEC_ASSERT(i<M, AT);
178 
179  return e(i);
180  }
181 
186  const AT& operator()(int i) const {
187 
188  FMATVEC_ASSERT(i>=0, AT);
189  FMATVEC_ASSERT(i<M, AT);
190 
191  return e(i);
192  }
193 
194  iterator begin() { return &ele[0]; }
195  iterator end() { return &ele[M]; }
196  const_iterator begin() const { return &ele[0]; }
197  const_iterator end() const { return &ele[M]; }
198  const_iterator cbegin() const noexcept { return &ele[0]; }
199  const_iterator cend() const noexcept { return &ele[M]; }
200 
201  AT& e(int i) {
202  return ele[i];
203  }
204 
209  const AT& e(int i) const {
210  return ele[i];
211  }
212 
220  inline Vector<Var,AT>& init(const AT& val=AT());
221  inline Vector<Var,AT>& init(Init, const AT& a=AT()) { return init(a); }
222  inline Vector<Var,AT>& init(Noinit, const AT& a=AT()) { return *this; }
223 
228  int size() const {return M;}
229 
236  int inc() const {return 1;}
237 
238  using Matrix<General,Var,Fixed<1>,AT>::operator();
239 
244  explicit inline operator std::vector<AT>() const;
245 
250  explicit inline Vector(const std::vector<AT> &v);
251 
252 // /*! \brief Cast to AT.
253 // *
254 // * \return The AT representation of the vector
255 // * */
256 // explicit operator AT() const {
257 // FMATVEC_ASSERT(M==1, AT);
258 // return ele[0];
259 // }
260 //
261 // /*! \brief AT Constructor.
262 // * Constructs and initializes a vector with a AT object.
263 // * \param x The AT the vector will be initialized with.
264 // * */
265 // explicit Vector(const AT &x) : Matrix<General,Var,Fixed<1>,AT>(x) { }
266 
267  inline const RowVector<Var,AT> T() const;
268 
269  inline const Vector<Var,AT> operator()(const fmatvec::Range<Var,Var> &I) const;
270 
271  template <class Row>
272  inline void set(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x);
273 
274  template <class Row>
275  inline void add(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x);
276  };
277 
278  template <class AT>
279  inline Vector<Var,AT>& Vector<Var,AT>::init(const AT &val) {
280  for(int i=0; i<M; i++)
281  e(i) = val;
282  return *this;
283  }
284 
285  template <class AT>
286  inline const RowVector<Var,AT> Vector<Var,AT>::T() const {
287  RowVector<Var,AT> x(M,NONINIT);
288  for(int i=0; i<M; i++)
289  x.e(i) = e(i);
290  return x;
291  }
292 
293  template <class AT>
294  inline Vector<Var,AT>::operator std::vector<AT>() const {
295  std::vector<AT> ret(size());
296  if(size()>0) memcpy(&ret[0], &operator()(0), sizeof(AT)*size());
297  return ret;
298  }
299 
300  template <class AT>
301  inline Vector<Var,AT>::Vector(const std::vector<AT> &v) : Matrix<General,Var,Fixed<1>,AT>(v.size(),1) {
302  if(size()>0) memcpy(&operator()(0), &v[0], sizeof(AT)*size());
303  }
304 
305  template <class AT>
306  inline const Vector<Var,AT> Vector<Var,AT>::operator()(const fmatvec::Range<Var,Var> &I) const {
307  FMATVEC_ASSERT(I.end()<M, AT);
308  Vector<Var,AT> x(I.end()-I.start()+1,NONINIT);
309 
310  for(int i=0; i<x.size(); i++)
311  x.e(i) = e(I.start()+i);
312 
313  return x;
314  }
315 
316  template <class AT> template <class Row>
317  inline void Vector<Var,AT>::set(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x) {
318  FMATVEC_ASSERT(I.end()<size(), AT);
319  FMATVEC_ASSERT(I.size()==x.size(), AT);
320 
321  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
322  e(i) = x.e(ii);
323  }
324 
325  template <class AT> template <class Row>
326  inline void Vector<Var,AT>::add(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x) {
327  FMATVEC_ASSERT(I.end()<size(), AT);
328  FMATVEC_ASSERT(I.size()==x.size(), AT);
329 
330  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
331  e(i) += x.e(ii);
332  }
333 
335 
336  template <class AT> template <class Row>
337  inline Vector<Var,AT>& Vector<Var,AT>::copy(const Vector<Row,AT> &x) {
338  for(int i=0; i<M; i++)
339  e(i) = x.e(i);
340  return *this;
341  }
342 
344 
345 }
346 
347 #endif
int end() const
Last element.
Definition: range.h:91
Definition: fmatvec.h:38
int size() const
Size.
Definition: var_vector.h:228
Vector(const Matrix< Type, Row, Col, AT > &A)
Copy Constructor.
Definition: var_vector.h:95
Vector(const char *str)
String Constructor.
Definition: var_vector.h:110
This is the basic matrix class for arbitrary matrices.
Definition: fmatvec.h:41
AT & operator()(int i)
Element operator.
Definition: var_vector.h:174
Definition: types.h:85
Definition: types.h:97
Vector(const Vector< Var, AT > &x)
Copy Constructor.
Definition: var_vector.h:77
Vector< Var, AT > & operator=(const Vector< Row, AT > &x)
Assignment operator.
Definition: var_vector.h:141
int inc() const
Increment.
Definition: var_vector.h:236
int start() const
First element.
Definition: range.h:85
Definition: fmatvec.h:47
Vector()
Standard constructor.
Definition: var_vector.h:64
Namespace fmatvec.
Definition: _memory.cc:28
int size() const
Size.
Definition: range.h:97
const AT & operator()(int i) const
Element operator.
Definition: var_vector.h:186
const AT & e(int i) const
Element operator.
Definition: var_vector.h:209
Definition: types.h:84
Basic shape class for matrices.
Definition: types.h:132
Vector(const Vector< Row, AT > &A)
Copy Constructor.
Definition: var_vector.h:86
Vector< Var, AT > & operator=(const Vector< Var, AT > &x)
Assignment operator.
Definition: var_vector.h:129
This is an index class for creating submatrices.
Definition: range.h:44
This is a vector class of general shape in dense storage format.
Definition: var_row_vector.h:39