fmatvec  0.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  static constexpr bool isVector {true};
45 
46  typedef AT* iterator;
47  typedef const AT* const_iterator;
48 
49  typedef AT value_type;
50 
52 
53  protected:
54 
55  template<class Row> inline Vector<Var,AT>& copy(const Vector<Row,AT> &x);
56 
58 
59  public:
60 
65  explicit Vector() : Matrix<General,Var,Fixed<1>,AT>() { }
66 
67 // template<class Ini=All<AT>>
68 // Vector(int m, Ini ini=All<AT>()) : Matrix<General,Var,Fixed<1>,AT>(m,ini) { }
69 
70  explicit Vector(int m, Noinit ini) : Matrix<General,Var,Fixed<1>,AT>(m,ini) { }
71  explicit Vector(int m, Init ini=INIT, const AT &a=AT()) : Matrix<General,Var,Fixed<1>,AT>(m,ini,a) { }
72 
78  Vector(const Vector<Var,AT> &x) : Matrix<General,Var,Fixed<1>,AT>(x) {
79  }
80 
86  template<class Row>
87  Vector(const Vector<Row,AT> &A) : Matrix<General,Var,Fixed<1>,AT>(A) {
88  }
89 
95  template<class Type, class Row, class Col>
96  explicit Vector(const Matrix<Type,Row,Col,AT> &A) : Matrix<General,Var,Fixed<1>,AT>(A) {
97  }
98 
111  Vector(const char *str) : Matrix<General,Var,Fixed<1>,AT>(str) {
112  }
113 
114  Vector<Var,AT>& resize(int m, Noinit) {
115  Matrix<General,Var,Fixed<1>,AT>::resize(m,Noinit());
116  return *this;
117  }
118 
119  Vector<Var,AT>& resize(int m, Init ini=INIT, const AT &a=AT()) {
120  Matrix<General,Var,Fixed<1>,AT>::resize(m,ini,a);
121  return *this;
122  }
123 
131  FMATVEC_ASSERT(M == x.size(), AT);
132  return copy(x);
133  }
134 
141  template <class Row>
143  FMATVEC_ASSERT(M == x.size(), AT);
144  return copy(x);
145  }
146 
153  template <class Row>
154  inline Vector<Var,AT>& operator<<=(const Vector<Row,AT> &x) {
155  if(M!=x.size()) resize(x.size(),NONINIT);
156  return copy(x);
157  }
158 
159  template <class AT2>
160  operator Vector<Var,AT2>() const {
161  Vector<Var,AT2> ret(size());
162  for(size_t i=0; i<size(); ++i)
163  ret(i) = (*this)(i);
164  return ret;
165  }
166 
175  AT& operator()(int i) {
176 
177  FMATVEC_ASSERT(i>=0, AT);
178  FMATVEC_ASSERT(i<M, AT);
179 
180  return e(i);
181  }
182 
187  const AT& operator()(int i) const {
188 
189  FMATVEC_ASSERT(i>=0, AT);
190  FMATVEC_ASSERT(i<M, AT);
191 
192  return e(i);
193  }
194 
195  iterator begin() { return &ele[0]; }
196  iterator end() { return &ele[M]; }
197  const_iterator begin() const { return &ele[0]; }
198  const_iterator end() const { return &ele[M]; }
199  const_iterator cbegin() const noexcept { return &ele[0]; }
200  const_iterator cend() const noexcept { return &ele[M]; }
201 
202  AT& e(int i) {
203  return ele[i];
204  }
205 
210  const AT& e(int i) const {
211  return ele[i];
212  }
213 
221  inline Vector<Var,AT>& init(const AT& val=AT());
222  inline Vector<Var,AT>& init(Init, const AT& a=AT()) { return init(a); }
223  inline Vector<Var,AT>& init(Noinit, const AT& a=AT()) { return *this; }
224 
229  constexpr int size() const {return M;}
230 
237  int inc() const {return 1;}
238 
239  using Matrix<General,Var,Fixed<1>,AT>::operator();
240 
245  explicit inline operator std::vector<AT>() const;
246 
251  explicit inline Vector(const std::vector<AT> &v);
252 
253 // /*! \brief Cast to AT.
254 // *
255 // * \return The AT representation of the vector
256 // * */
257 // explicit operator AT() const {
258 // FMATVEC_ASSERT(M==1, AT);
259 // return ele[0];
260 // }
261 //
262 // /*! \brief AT Constructor.
263 // * Constructs and initializes a vector with a AT object.
264 // * \param x The AT the vector will be initialized with.
265 // * */
266 // explicit Vector(const AT &x) : Matrix<General,Var,Fixed<1>,AT>(x) { }
267 
268  inline const RowVector<Var,AT> T() const;
269 
270  inline const Vector<Var,AT> operator()(const fmatvec::Range<Var,Var> &I) const;
271 
272  template <class Row>
273  inline void set(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x);
274 
275  template <class Row>
276  inline void add(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x);
277  };
278 
279  template <class AT>
280  inline Vector<Var,AT>& Vector<Var,AT>::init(const AT &val) {
281  for(int i=0; i<M; i++)
282  e(i) = val;
283  return *this;
284  }
285 
286  template <class AT>
287  inline const RowVector<Var,AT> Vector<Var,AT>::T() const {
288  RowVector<Var,AT> x(M,NONINIT);
289  for(int i=0; i<M; i++)
290  x.e(i) = e(i);
291  return x;
292  }
293 
294  template <class AT>
295  inline Vector<Var,AT>::operator std::vector<AT>() const {
296  std::vector<AT> ret(size());
297  for(int i=0; i<size(); ++i)
298  ret[i] = operator()(i);
299  return ret;
300  }
301 
302  template <class AT>
303  inline Vector<Var,AT>::Vector(const std::vector<AT> &v) : Matrix<General,Var,Fixed<1>,AT>(static_cast<int>(v.size()),1) {
304  for(int i=0; i<size(); ++i)
305  operator()(i) = v[i];
306  }
307 
308  template <class AT>
309  inline const Vector<Var,AT> Vector<Var,AT>::operator()(const fmatvec::Range<Var,Var> &I) const {
310  FMATVEC_ASSERT(I.end()<M, AT);
311  Vector<Var,AT> x(I.end()-I.start()+1,NONINIT);
312 
313  for(int i=0; i<x.size(); i++)
314  x.e(i) = e(I.start()+i);
315 
316  return x;
317  }
318 
319  template <class AT> template <class Row>
320  inline void Vector<Var,AT>::set(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x) {
321  FMATVEC_ASSERT(I.end()<size(), AT);
322  FMATVEC_ASSERT(I.size()==x.size(), AT);
323 
324  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
325  e(i) = x.e(ii);
326  }
327 
328  template <class AT> template <class Row>
329  inline void Vector<Var,AT>::add(const fmatvec::Range<Var,Var> &I, const Vector<Row,AT> &x) {
330  FMATVEC_ASSERT(I.end()<size(), AT);
331  FMATVEC_ASSERT(I.size()==x.size(), AT);
332 
333  for(int i=I.start(), ii=0; i<=I.end(); i++, ii++)
334  e(i) += x.e(ii);
335  }
336 
338 
339  template <class AT> template <class Row>
340  inline Vector<Var,AT>& Vector<Var,AT>::copy(const Vector<Row,AT> &x) {
341  for(int i=0; i<M; i++)
342  e(i) = x.e(i);
343  return *this;
344  }
345 
347 
348 }
349 
350 #endif
int end() const
Last element.
Definition: range.h:91
Definition: fmatvec.h:38
Vector(const Matrix< Type, Row, Col, AT > &A)
Copy Constructor.
Definition: var_vector.h:96
Vector(const char *str)
String Constructor.
Definition: var_vector.h:111
This is the basic matrix class for arbitrary matrices.
Definition: fmatvec.h:41
AT & operator()(int i)
Element operator.
Definition: var_vector.h:175
Definition: types.h:85
Definition: types.h:97
Vector(const Vector< Var, AT > &x)
Copy Constructor.
Definition: var_vector.h:78
Vector< Var, AT > & operator=(const Vector< Row, AT > &x)
Assignment operator.
Definition: var_vector.h:142
int inc() const
Increment.
Definition: var_vector.h:237
int start() const
First element.
Definition: range.h:85
Definition: fmatvec.h:47
Vector()
Standard constructor.
Definition: var_vector.h:65
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:187
constexpr int size() const
Size.
Definition: var_vector.h:229
const AT & e(int i) const
Element operator.
Definition: var_vector.h:210
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:87
Vector< Var, AT > & operator=(const Vector< Var, AT > &x)
Assignment operator.
Definition: var_vector.h:130
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