You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
matrixIterator.hh
Go to the documentation of this file.
1
6#ifndef matrixIterator_hh
7#define matrixIterator_hh
8
9#include <cstddef>
10#include <bits/stl_iterator_base_types.h>
11#include "basics/exceptions.hh"
12#include "basics/outputOperator.hh"
13
14namespace concepts {
15
16 // forward declaration
17 template<class F>
18 class Matrix;
19
20 // ************************************************* _Matrix_iterator_base **
21
27 template <class _Tp, class _Ref, class _Ptr>
28 class _Matrix_iterator_base : public virtual OutputOperator {
29 public:
30 typedef _Matrix_iterator_base<_Tp, _Tp&, _Tp*> iterator;
31 typedef _Matrix_iterator_base<_Tp, const _Tp&, const _Tp*> const_iterator;
32
37 template<class _Tp_>
38 struct ReturnType;
39
40 typedef _Tp value_type;
41 typedef _Ptr pointer;
42 typedef _Ref reference;
43 typedef size_t size_type;
44 typedef ptrdiff_t difference_type;
45 typedef typename ReturnType<_Ref>::type return_type;
46 typedef _Matrix_iterator_base _Self;
47
55 _Matrix_iterator_base(const unsigned int nofRows, const unsigned int nofCols,
56 const unsigned int r, const unsigned int c);
58 _Matrix_iterator_base();
63 template<class _RefR, class _PtrR>
67
69 inline const unsigned int nofRows() const { return nofRows_; }
71 inline const unsigned int nofCols() const { return nofCols_; }
73 inline unsigned int row() const { return row_; }
75 inline unsigned int col() const { return col_; }
77 inline bool last() const { return last_; }
78
80 _Self& operator=(const iterator& __x) {
81 conceptsAssert(nofRows_ == __x.nofRows() && nofCols_ == __x.nofCols(),
82 Assertion());
83 row_ = __x.row();
84 col_ = __x.col();
85 last_ = __x.last();
86 return *this;
87 }
88 protected:
89 virtual std::ostream& info(std::ostream& os) const;
91 const unsigned int nofRows_, nofCols_;
93 unsigned int row_, col_;
95 bool last_;
96 };
97
101 template <class _Tp, class _Ref, class _Ptr>
102 template<class _Tp_>
103 struct _Matrix_iterator_base<_Tp, _Ref, _Ptr>::ReturnType {
104 typedef _Tp_ type;
105 };
106
110 template <class _Tp, class _Ref, class _Ptr>
111 template<class _Tp_>
112 struct _Matrix_iterator_base<_Tp, _Ref, _Ptr>::ReturnType<const _Tp_&> {
113 typedef const _Tp_ type;
114 };
115
116 template <class _Tp, class _Ref, class _Ptr>
117 std::ostream&
118 _Matrix_iterator_base<_Tp, _Ref, _Ptr>::info(std::ostream& os) const {
119 os << "_Matrix_iterator_base(pos = ";
120 if (!last_)
121 os << "(" << row_ << ", " << col_ << ")";
122 else os << "end)";
123 return os;
124 }
125
126 // *************
127
128 template <class _Tp, class _Ref, class _Ptr>
129 inline bool
130 operator==(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
131 const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
132 {
133 return (__x.last() && __y.last()) ||
134 (!__x.last() && !__y.last() &&
135 __x.row() == __y.row() && __x.col() == __y.col());
136 }
137
138 template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
139 inline bool
140 operator==(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
141 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
142 {
143 return (__x.last() && __y.last()) ||
144 (!__x.last() && !__y.last() &&
145 __x.row() == __y.row() && __x.col() == __y.col());
146 }
147
148 template <class _Tp, class _Ref, class _Ptr>
149 inline bool
150 operator!=(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
151 const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
152 {
153 return !(__x == __y);
154 }
155
156 template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
157 inline bool
158 operator!=(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
159 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
160 {
161 return !(__x == __y);
162 }
163
164 template <class _Tp, class _Ref, class _Ptr>
165 inline bool
166 operator<(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
167 const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
168 {
169 return !__x.last() &&
170 (__y.last() || ((!__y.last() && __x.row() < __y.row()) ||
171 (__x.row() == __y.row() && __x.col() < __y.col())));
172 }
173
174 template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
175 inline bool
176 operator<(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
177 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
178 {
179 return !__x.last() &&
180 (__y.last() || (!__y.last() && __x.row() < __y.row()) ||
181 (__x.row() == __y.row() && __x.col() < __y.col()));
182 }
183
184 template <class _Tp, class _Ref, class _Ptr>
185 inline bool
186 operator>(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
187 const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
188 {
189 return __y < __x;
190 }
191
192 template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
193 inline bool
194 operator>(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
195 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
196 {
197 return __y < __x;
198 }
199
200 template <class _Tp, class _Ref, class _Ptr>
201 inline bool
202 operator<=(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
203 const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
204 {
205 return !(__y < __x);
206 }
207
208 template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
209 inline bool
210 operator<=(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
211 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
212 {
213 return !(__y < __x);
214 }
215
216 template <class _Tp, class _Ref, class _Ptr>
217 inline bool
218 operator>=(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
219 const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
220 {
221 return !(__x < __y);
222 }
223
224 template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
225 inline bool
226 operator>=(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
227 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
228 {
229 return !(__x < __y);
230 }
231
232 template <typename _Tp, typename _RefL, typename _PtrL,
233 typename _RefR, typename _PtrR>
234 inline typename _Matrix_iterator_base<_Tp, _RefL, _PtrL>::difference_type
235 operator-(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
236 const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
237 {
238 if (__x.last())
239 if (__y.last()) return 0;
240 else return __y.nofRows() * (__y.nofCols() - __y.row()) - __y.col();
241 else if (__y.last())
242 return __x.nofRows() * (__x.nofCols() - __x.row()) - __x.col();
243 return typename _Matrix_iterator_base<_Tp, _RefL, _PtrL>::difference_type
244 (__x.col() - __y.col() + __x.nofCols() * (__x.row() - __y.row()));
245 }
246
247 template <class _Tp, class _Ref, class _Ptr>
248 inline _Matrix_iterator_base<_Tp, _Ref, _Ptr>
249 operator+(ptrdiff_t __n, const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x)
250 {
251 return __x + __n;
252 }
253
254 // ****************************************************** securePointer **
255
261 template<class F, class G>
262 F* securePointer(F& value, G* matrix) { return &value; }
263
264 template<class F, class G>
265 F* securePointer(const F value, const G* matrix) {
266 throw conceptsException(MissingFeature
267 ("inapplicable for constant matrices"));
268 return 0;
269 }
270
271 // ****************************************************** _Matrix_iterator **
272
277 template <class _Tp, class _Ref, class _Ptr>
278 class _Matrix_iterator : public _Matrix_iterator_base<_Tp, _Ref, _Ptr> {
279 public:
280 typedef _Matrix_iterator<_Tp, _Tp&, _Tp*> iterator;
281 typedef _Matrix_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
282
283 template<class _Tp_, class _Ref_, class _Ptr_>
284 struct MatrixType;
285
286 typedef std::random_access_iterator_tag iterator_category;
287 typedef _Tp value_type;
288 typedef _Ptr pointer;
289 typedef _Ref reference;
290 typedef size_t size_type;
291 typedef ptrdiff_t difference_type;
292 typedef _Matrix_iterator _Self;
293 typedef _Matrix_iterator_base<_Tp, _Ref, _Ptr> _Base;
294 typedef typename MatrixType<_Tp, _Ref, _Ptr>::type matrix_type;
295 typedef typename _Base::return_type return_type;
296
303 _Matrix_iterator(matrix_type& m, const unsigned int r = 0, const unsigned int c = 0);
305 _Matrix_iterator();
307 template<class _RefR, class _PtrR>
310
312 return_type operator*() const {
313 conceptsAssert(matrix_, Assertion());
314 return (*matrix_)(this->row_, this->col_);
315 }
322 pointer operator->() const {
323 conceptsAssert(matrix_, Assertion());
324 return securePointer((*matrix_)(this->row_, this->col_), matrix_);
325 }
326
328 inline matrix_type* matrix() const { return matrix_; }
329
331 _Self& operator=(const iterator& __x) {
332 conceptsAssert(matrix_ == __x.matrix(), Assertion());
333 _Base::operator=(__x);
334 return *this;
335 }
336
337 _Self& operator++() {
338 if (!this->last_) {
339 if (++this->col_ >= this->nofCols_) {
340 ++this->row_;
341 this->col_ = 0;
342 }
343 this->last_ = this->row_ >= this->nofRows_;
344 }
345 return *this;
346 }
347 _Self operator++(int) {
348 _Self __tmp = *this;
349 ++*this;
350 return __tmp;
351 }
352
353 _Self& operator--() {
354 if (this->last_) {
355 conceptsAssert(matrix_, Assertion());
356 this->col_ = this->nofCols_ - 1;
357 this->row_ = this->nofRows_ - 1;
358 this->last_ = false;
359 } else {
360 if (this->col_ > 0) --this->col_;
361 else {
362 conceptsAssert(this->row_ > 0, Assertion());
363 --this->row_;
364 this->col_ = this->nofCols_ - 1;
365 }
366 }
367 return *this;
368 }
369 _Self operator--(int) {
370 _Self __tmp = *this;
371 --*this;
372 return __tmp;
373 }
374
375 _Self& operator+=(difference_type __n)
376 {
377 if (this->last_ && __n < 0) {
378 this->col_ = 0;
379 this->row_ = this->nofRows_;
380 this->last_ = false;
381 }
382 if (!this->last_) {
383 conceptsAssert(this->nofCols_, Assertion());
384 int col = __n + this->col_;
385 int row = col / (int)this->nofCols_ + this->row_;
386 conceptsAssert(row >= 0 , Assertion());
387 this->row_ = row;
388 this->col_ = col % this->nofCols_;
389 this->last_ = this->row_ >= this->nofRows_;
390 }
391 return *this;
392 }
393
394 _Self operator+(difference_type __n) const
395 {
396 _Self __tmp = *this;
397 return __tmp += __n;
398 }
399
400 _Self& operator-=(difference_type __n) { return *this += -__n; }
401
402 _Self operator-(difference_type __n) const {
403 _Self __tmp = *this;
404 return __tmp -= __n;
405 }
406
407 return_type operator[](difference_type __n) const {
408 return *(*this + __n);
409 }
410 protected:
411 virtual std::ostream& info(std::ostream& os) const;
412 private:
414 matrix_type* matrix_;
415 };
416
418 template <class _Tp, class _Ref, class _Ptr>
419 template<class _Tp_, class _Ref_, class _Ptr_>
420 struct _Matrix_iterator<_Tp, _Ref, _Ptr>::MatrixType {
421 typedef Matrix<_Tp_> type;
422 };
423
425 template <class _Tp, class _Ref, class _Ptr>
426 template<class _Tp_>
427 struct _Matrix_iterator<_Tp, _Ref, _Ptr>::
428 MatrixType<_Tp_, const _Tp_&, const _Tp_*>
429 {
430 typedef const Matrix<_Tp_> type;
431 };
432
433 // *************
434
435// template <class _Tp, class _Ref, class _Ptr, class G>
436// inline bool
437// operator==(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
438// const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
439// {
440// return __x.last() && __y.last() ||
441// (!__x.last() && !__y.last() &&
442// __x.row() == __y.row() && __x.col() == __y.col());
443// }
444
445// template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
446// class G>
447// inline bool
448// operator==(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
449// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
450// {
451// return __x.last() && __y.last() ||
452// (!__x.last() && !__y.last() &&
453// __x.row() == __y.row() && __x.col() == __y.col());
454// }
455
456// template <class _Tp, class _Ref, class _Ptr, class G>
457// inline bool
458// operator!=(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
459// const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
460// {
461// return !(__x == __y);
462// }
463
464// template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
465// class G>
466// inline bool
467// operator!=(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
468// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
469// {
470// return !(__x == __y);
471// }
472
473// template <class _Tp, class _Ref, class _Ptr, class G>
474// inline bool
475// operator<(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
476// const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
477// {
478// return !__x.last() &&
479// (__y.last() || (!__y.last() && __x.row() < __y.row() ||
480// (__x.row() == __y.row() && __x.col() < __y.col())));
481// }
482
483// template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
484// class G>
485// inline bool
486// operator<(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
487// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
488// {
489// return !__x.last() &&
490// (__y.last() || (!__y.last() && __x.row() < __y.row() ||
491// (__x.row() == __y.row() && __x.col() < __y.col())));
492// }
493
494// template <class _Tp, class _Ref, class _Ptr, class G>
495// inline bool
496// operator>(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
497// const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
498// {
499// return __y < __x;
500// }
501
502// template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
503// class G>
504// inline bool
505// operator>(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
506// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
507// {
508// return __y < __x;
509// }
510
511// template <class _Tp, class _Ref, class _Ptr, class G>
512// inline bool
513// operator<=(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
514// const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
515// {
516// return !(__y < __x);
517// }
518
519// template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
520// class G>
521// inline bool
522// operator<=(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
523// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
524// {
525// return !(__y < __x);
526// }
527
528// template <class _Tp, class _Ref, class _Ptr, class G>
529// inline bool
530// operator>=(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
531// const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
532// {
533// return !(__x < __y);
534// }
535
536// template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
537// class G>
538// inline bool
539// operator>=(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
540// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
541// {
542// return !(__x < __y);
543// }
544
545// template <typename _Tp, typename _RefL, typename _PtrL,
546// typename _RefR, typename _PtrR, typename G>
547// inline typename _Matrix_iterator<_Tp, _RefL, _PtrL, G>::difference_type
548// operator-(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
549// const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
550// {
551// if (__x.last())
552// if (__y.last()) return 0;
553// else return __y.nofRows() * (__y.nofCols() - __y.row()) - __y.col();
554// else if (__y.last())
555// return __x.nofRows() * (__x.nofCols() - __x.row()) - __x.col();
556// return _Matrix_iterator<_Tp, _RefL, _PtrL, G>::difference_type
557// (__x.col() - __y.col() + __x.nofCols() * (__x.row() - __y.row()));
558// }
559
560// template <class _Tp, class _Ref, class _Ptr, class G>
561// inline _Matrix_iterator<_Tp, _Ref, _Ptr, G>
562// operator+(ptrdiff_t __n, const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x)
563// {
564// return __x + __n;
565// }
566
567} // namespace concepts
568
569#endif // matrixIterator_hh
conceptsException
#define conceptsException(exc)
Definition exceptions.hh:344
concepts::_Matrix_iterator_base
Definition matrixIterator.hh:28
concepts::_Matrix_iterator_base::nofRows_
const unsigned int nofRows_
Number of rows and columns.
Definition matrixIterator.hh:91
concepts::_Matrix_iterator_base::_Matrix_iterator_base
_Matrix_iterator_base(const unsigned int nofRows, const unsigned int nofCols, const unsigned int r, const unsigned int c)
concepts::_Matrix_iterator_base::_Matrix_iterator_base
_Matrix_iterator_base()
Constructor. Iterator stands at the end of any matrix.
concepts::_Matrix_iterator_base::row
unsigned int row() const
Row.
Definition matrixIterator.hh:73
concepts::_Matrix_iterator_base::row_
unsigned int row_
Current row and column.
Definition matrixIterator.hh:93
concepts::_Matrix_iterator_base::operator=
_Self & operator=(const iterator &__x)
Assignment.
Definition matrixIterator.hh:80
concepts::_Matrix_iterator_base::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition matrixIterator.hh:118
concepts::_Matrix_iterator_base::col
unsigned int col() const
Column.
Definition matrixIterator.hh:75
concepts::_Matrix_iterator_base::_Matrix_iterator_base
_Matrix_iterator_base(const _Matrix_iterator_base< _Tp, _RefR, _PtrR > &__x)
Definition matrixIterator.hh:64
concepts::_Matrix_iterator_base::last
bool last() const
Returns true, if iterator is behind the last entry.
Definition matrixIterator.hh:77
concepts::_Matrix_iterator_base::nofCols
const unsigned int nofCols() const
Number of columns.
Definition matrixIterator.hh:71
concepts::_Matrix_iterator_base::nofRows
const unsigned int nofRows() const
Number of rows.
Definition matrixIterator.hh:69
concepts::_Matrix_iterator_base::last_
bool last_
Iterator is behind the last entrance.
Definition matrixIterator.hh:95
concepts::_Matrix_iterator
Definition matrixIterator.hh:278
concepts::_Matrix_iterator::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
concepts::_Matrix_iterator::_Matrix_iterator
_Matrix_iterator()
Constructor. Iterator stands at the end of any matrix.
concepts::_Matrix_iterator::_Matrix_iterator
_Matrix_iterator(matrix_type &m, const unsigned int r=0, const unsigned int c=0)
concepts::_Matrix_iterator::_Matrix_iterator
_Matrix_iterator(const _Matrix_iterator< _Tp, _RefR, _PtrR > &__x)
Copy constructor. Also from iterator to constant iterator.
Definition matrixIterator.hh:308
concepts::_Matrix_iterator::operator=
_Self & operator=(const iterator &__x)
Assignment.
Definition matrixIterator.hh:331
concepts::_Matrix_iterator::operator*
return_type operator*() const
Dereferencation.
Definition matrixIterator.hh:312
concepts::_Matrix_iterator::operator->
pointer operator->() const
Definition matrixIterator.hh:322
concepts::_Matrix_iterator::matrix
matrix_type * matrix() const
Pointer to the matrix, needed for copy constructor.
Definition matrixIterator.hh:328
conceptsAssert
#define conceptsAssert(cond, exc)
Definition exceptions.hh:394
concepts::operator<
bool operator<(const Cell &cell_x, const Cell &cell_y)
<-operator could be useful for sorting, e.g. in std::set.
concepts::operator-
ElementFormulaContainer< Real > operator-(const ElementFormulaContainer< Real > frm, const Real a)
Simple subtracting of a element formulas and a constant via –operator.
concepts::operator+
Frm_Sum< Real > operator+(const Formula< Real > &frm, const Real a)
concepts::securePointer
F * securePointer(F &value, G *matrix)
Definition matrixIterator.hh:262
concepts::makeSet
Set< F > makeSet(uint n, const F &first,...)
Definition set.hh:320
concepts::_Matrix_iterator::MatrixType
Non-constant matrix for non-constant iterator.
Definition matrixIterator.hh:420
concepts::_Matrix_iterator_base::ReturnType
Definition matrixIterator.hh:103
Generated on Wed Sep 13 2023 21:06:22 for Concepts by doxygen 1.9.8