Gitiles
Code Review Sign In
realtimeroboticsgroup.org / RealtimeRoboticsGroup / test / dc6866bfe21cff39c0481df3fb8a37d6f44f3e4d / . / include / boost / numeric / ublas / matrix_expression.hpp
blob: a36313096e45d47f0e3e9ea2d1c7ee2e7c1d8532 [file] [log] [blame]
Brian Silvermandc6866b2018-08-05 00:18:23 -0700[diff] [blame^]1//
2// Copyright (c) 2000-2002
3// Joerg Walter, Mathias Koch
4//
5// Distributed under the Boost Software License, Version 1.0. (See
6// accompanying file LICENSE_1_0.txt or copy at
7// http://www.boost.org/LICENSE_1_0.txt)
8//
9// The authors gratefully acknowledge the support of
10// GeNeSys mbH & Co. KG in producing this work.
11//
12
13#ifndef _BOOST_UBLAS_MATRIX_EXPRESSION_
14#define _BOOST_UBLAS_MATRIX_EXPRESSION_
15
16#include <boost/numeric/ublas/vector_expression.hpp>
17
18// Expression templates based on ideas of Todd Veldhuizen and Geoffrey Furnish
19// Iterators based on ideas of Jeremy Siek
20//
21// Classes that model the Matrix Expression concept
22
23namespace boost { namespace numeric { namespace ublas {
24
25 template<class E>
26 class matrix_reference:
27 public matrix_expression<matrix_reference<E> > {
28
29 typedef matrix_reference<E> self_type;
30 public:
31#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
32 using matrix_expression<self_type>::operator ();
33#endif
34 typedef typename E::size_type size_type;
35 typedef typename E::difference_type difference_type;
36 typedef typename E::value_type value_type;
37 typedef typename E::const_reference const_reference;
38 typedef typename boost::mpl::if_<boost::is_const<E>,
39 typename E::const_reference,
40 typename E::reference>::type reference;
41 typedef E referred_type;
42 typedef const self_type const_closure_type;
43 typedef self_type closure_type;
44 typedef typename E::orientation_category orientation_category;
45 typedef typename E::storage_category storage_category;
46
47 // Construction and destruction
48 BOOST_UBLAS_INLINE
49 explicit matrix_reference (referred_type &e):
50 e_ (e) {}
51
52 // Accessors
53 BOOST_UBLAS_INLINE
54 size_type size1 () const {
55 return e_.size1 ();
56 }
57 BOOST_UBLAS_INLINE
58 size_type size2 () const {
59 return e_.size2 ();
60 }
61
62 public:
63 // Expression accessors - const correct
64 BOOST_UBLAS_INLINE
65 const referred_type &expression () const {
66 return e_;
67 }
68 BOOST_UBLAS_INLINE
69 referred_type &expression () {
70 return e_;
71 }
72
73 public:
74 // Element access
75#ifndef BOOST_UBLAS_REFERENCE_CONST_MEMBER
76 BOOST_UBLAS_INLINE
77 const_reference operator () (size_type i, size_type j) const {
78 return expression () (i, j);
79 }
80 BOOST_UBLAS_INLINE
81 reference operator () (size_type i, size_type j) {
82 return expression () (i, j);
83 }
84#else
85 BOOST_UBLAS_INLINE
86 reference operator () (size_type i, size_type j) const {
87 return expression () (i, j);
88 }
89#endif
90
91 // Assignment
92 BOOST_UBLAS_INLINE
93 matrix_reference &operator = (const matrix_reference &m) {
94 expression ().operator = (m);
95 return *this;
96 }
97 template<class AE>
98 BOOST_UBLAS_INLINE
99 matrix_reference &operator = (const matrix_expression<AE> &ae) {
100 expression ().operator = (ae);
101 return *this;
102 }
103 template<class AE>
104 BOOST_UBLAS_INLINE
105 matrix_reference &assign (const matrix_expression<AE> &ae) {
106 expression ().assign (ae);
107 return *this;
108 }
109 template<class AE>
110 BOOST_UBLAS_INLINE
111 matrix_reference &operator += (const matrix_expression<AE> &ae) {
112 expression ().operator += (ae);
113 return *this;
114 }
115 template<class AE>
116 BOOST_UBLAS_INLINE
117 matrix_reference &plus_assign (const matrix_expression<AE> &ae) {
118 expression ().plus_assign (ae);
119 return *this;
120 }
121 template<class AE>
122 BOOST_UBLAS_INLINE
123 matrix_reference &operator -= (const matrix_expression<AE> &ae) {
124 expression ().operator -= (ae);
125 return *this;
126 }
127 template<class AE>
128 BOOST_UBLAS_INLINE
129 matrix_reference &minus_assign (const matrix_expression<AE> &ae) {
130 expression ().minus_assign (ae);
131 return *this;
132 }
133 template<class AT>
134 BOOST_UBLAS_INLINE
135 matrix_reference &operator *= (const AT &at) {
136 expression ().operator *= (at);
137 return *this;
138 }
139 template<class AT>
140 BOOST_UBLAS_INLINE
141 matrix_reference &operator /= (const AT &at) {
142 expression ().operator /= (at);
143 return *this;
144 }
145
146 // Swapping
147 BOOST_UBLAS_INLINE
148 void swap (matrix_reference &m) {
149 expression ().swap (m.expression ());
150 }
151
152 // Closure comparison
153 BOOST_UBLAS_INLINE
154 bool same_closure (const matrix_reference &mr) const {
155 return &(*this).e_ == &mr.e_;
156 }
157
158 // Iterator types
159 typedef typename E::const_iterator1 const_iterator1;
160 typedef typename boost::mpl::if_<boost::is_const<E>,
161 typename E::const_iterator1,
162 typename E::iterator1>::type iterator1;
163 typedef typename E::const_iterator2 const_iterator2;
164 typedef typename boost::mpl::if_<boost::is_const<E>,
165 typename E::const_iterator2,
166 typename E::iterator2>::type iterator2;
167
168 // Element lookup
169 BOOST_UBLAS_INLINE
170 const_iterator1 find1 (int rank, size_type i, size_type j) const {
171 return expression ().find1 (rank, i, j);
172 }
173 BOOST_UBLAS_INLINE
174 iterator1 find1 (int rank, size_type i, size_type j) {
175 return expression ().find1 (rank, i, j);
176 }
177 BOOST_UBLAS_INLINE
178 const_iterator2 find2 (int rank, size_type i, size_type j) const {
179 return expression ().find2 (rank, i, j);
180 }
181 BOOST_UBLAS_INLINE
182 iterator2 find2 (int rank, size_type i, size_type j) {
183 return expression ().find2 (rank, i, j);
184 }
185
186 // Iterators are the iterators of the referenced expression.
187
188 BOOST_UBLAS_INLINE
189 const_iterator1 begin1 () const {
190 return expression ().begin1 ();
191 }
192 BOOST_UBLAS_INLINE
193 const_iterator1 cbegin1 () const {
194 return begin1 ();
195 }
196 BOOST_UBLAS_INLINE
197 const_iterator1 end1 () const {
198 return expression ().end1 ();
199 }
200 BOOST_UBLAS_INLINE
201 const_iterator1 cend1 () const {
202 return end1 ();
203 }
204
205 BOOST_UBLAS_INLINE
206 iterator1 begin1 () {
207 return expression ().begin1 ();
208 }
209 BOOST_UBLAS_INLINE
210 iterator1 end1 () {
211 return expression ().end1 ();
212 }
213
214 BOOST_UBLAS_INLINE
215 const_iterator2 begin2 () const {
216 return expression ().begin2 ();
217 }
218 BOOST_UBLAS_INLINE
219 const_iterator2 cbegin2 () const {
220 return begin2 ();
221 }
222 BOOST_UBLAS_INLINE
223 const_iterator2 end2 () const {
224 return expression ().end2 ();
225 }
226 BOOST_UBLAS_INLINE
227 const_iterator2 cend2 () const {
228 return end2 ();
229 }
230
231 BOOST_UBLAS_INLINE
232 iterator2 begin2 () {
233 return expression ().begin2 ();
234 }
235 BOOST_UBLAS_INLINE
236 iterator2 end2 () {
237 return expression ().end2 ();
238 }
239
240 // Reverse iterators
241 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
242 typedef reverse_iterator_base1<iterator1> reverse_iterator1;
243
244 BOOST_UBLAS_INLINE
245 const_reverse_iterator1 rbegin1 () const {
246 return const_reverse_iterator1 (end1 ());
247 }
248 BOOST_UBLAS_INLINE
249 const_reverse_iterator1 crbegin1 () const {
250 return rbegin1 ();
251 }
252 BOOST_UBLAS_INLINE
253 const_reverse_iterator1 rend1 () const {
254 return const_reverse_iterator1 (begin1 ());
255 }
256 BOOST_UBLAS_INLINE
257 const_reverse_iterator1 crend1 () const {
258 return rend1 ();
259 }
260
261 BOOST_UBLAS_INLINE
262 reverse_iterator1 rbegin1 () {
263 return reverse_iterator1 (end1 ());
264 }
265 BOOST_UBLAS_INLINE
266 reverse_iterator1 rend1 () {
267 return reverse_iterator1 (begin1 ());
268 }
269
270 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
271 typedef reverse_iterator_base2<iterator2> reverse_iterator2;
272
273 BOOST_UBLAS_INLINE
274 const_reverse_iterator2 rbegin2 () const {
275 return const_reverse_iterator2 (end2 ());
276 }
277 BOOST_UBLAS_INLINE
278 const_reverse_iterator2 crbegin2 () const {
279 return rbegin2 ();
280 }
281 BOOST_UBLAS_INLINE
282 const_reverse_iterator2 rend2 () const {
283 return const_reverse_iterator2 (begin2 ());
284 }
285 BOOST_UBLAS_INLINE
286 const_reverse_iterator2 crend2 () const {
287 return rend2 ();
288 }
289
290 BOOST_UBLAS_INLINE
291 reverse_iterator2 rbegin2 () {
292 return reverse_iterator2 (end2 ());
293 }
294 BOOST_UBLAS_INLINE
295 reverse_iterator2 rend2 () {
296 return reverse_iterator2 (begin2 ());
297 }
298
299 private:
300 referred_type &e_;
301 };
302
303
304 template<class E1, class E2, class F>
305 class vector_matrix_binary:
306 public matrix_expression<vector_matrix_binary<E1, E2, F> > {
307
308 typedef E1 expression1_type;
309 typedef E2 expression2_type;
310 public:
311 typedef typename E1::const_closure_type expression1_closure_type;
312 typedef typename E2::const_closure_type expression2_closure_type;
313 private:
314 typedef vector_matrix_binary<E1, E2, F> self_type;
315 public:
316#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
317 using matrix_expression<self_type>::operator ();
318#endif
319 typedef F functor_type;
320 typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
321 typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
322 typedef typename F::result_type value_type;
323 typedef value_type const_reference;
324 typedef const_reference reference;
325 typedef const self_type const_closure_type;
326 typedef const_closure_type closure_type;
327 typedef unknown_orientation_tag orientation_category;
328 typedef unknown_storage_tag storage_category;
329
330 // Construction and destruction
331 BOOST_UBLAS_INLINE
332 vector_matrix_binary (const expression1_type &e1, const expression2_type &e2):
333 e1_ (e1), e2_ (e2) {}
334
335 // Accessors
336 BOOST_UBLAS_INLINE
337 size_type size1 () const {
338 return e1_.size ();
339 }
340 BOOST_UBLAS_INLINE
341 size_type size2 () const {
342 return e2_.size ();
343 }
344
345 public:
346 // Expression accessors
347 BOOST_UBLAS_INLINE
348 const expression1_closure_type &expression1 () const {
349 return e1_;
350 }
351 BOOST_UBLAS_INLINE
352 const expression2_closure_type &expression2 () const {
353 return e2_;
354 }
355
356 public:
357 // Element access
358 BOOST_UBLAS_INLINE
359 const_reference operator () (size_type i, size_type j) const {
360 return functor_type::apply (e1_ (i), e2_ (j));
361 }
362
363 // Closure comparison
364 BOOST_UBLAS_INLINE
365 bool same_closure (const vector_matrix_binary &vmb) const {
366 return (*this).expression1 ().same_closure (vmb.expression1 ()) &&
367 (*this).expression2 ().same_closure (vmb.expression2 ());
368 }
369
370 // Iterator types
371 private:
372 typedef typename E1::const_iterator const_subiterator1_type;
373 typedef typename E2::const_iterator const_subiterator2_type;
374 typedef const value_type *const_pointer;
375
376 public:
377#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
378 typedef typename iterator_restrict_traits<typename const_subiterator1_type::iterator_category,
379 typename const_subiterator2_type::iterator_category>::iterator_category iterator_category;
380 typedef indexed_const_iterator1<const_closure_type, iterator_category> const_iterator1;
381 typedef const_iterator1 iterator1;
382 typedef indexed_const_iterator2<const_closure_type, iterator_category> const_iterator2;
383 typedef const_iterator2 iterator2;
384#else
385 class const_iterator1;
386 typedef const_iterator1 iterator1;
387 class const_iterator2;
388 typedef const_iterator2 iterator2;
389#endif
390 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
391 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
392
393 // Element lookup
394 BOOST_UBLAS_INLINE
395 const_iterator1 find1 (int rank, size_type i, size_type j) const {
396 const_subiterator1_type it1 (e1_.find (i));
397 const_subiterator1_type it1_end (e1_.find (size1 ()));
398 const_subiterator2_type it2 (e2_.find (j));
399 const_subiterator2_type it2_end (e2_.find (size2 ()));
400 if (it2 == it2_end || (rank == 1 && (it2.index () != j || *it2 == value_type/*zero*/()))) {
401 it1 = it1_end;
402 it2 = it2_end;
403 }
404#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
405 return const_iterator1 (*this, it1.index (), it2.index ());
406#else
407#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
408 return const_iterator1 (*this, it1, it2, it2 != it2_end ? *it2 : value_type/*zero*/());
409#else
410 return const_iterator1 (*this, it1, it2);
411#endif
412#endif
413 }
414 BOOST_UBLAS_INLINE
415 const_iterator2 find2 (int rank, size_type i, size_type j) const {
416 const_subiterator2_type it2 (e2_.find (j));
417 const_subiterator2_type it2_end (e2_.find (size2 ()));
418 const_subiterator1_type it1 (e1_.find (i));
419 const_subiterator1_type it1_end (e1_.find (size1 ()));
420 if (it1 == it1_end || (rank == 1 && (it1.index () != i || *it1 == value_type/*zero*/()))) {
421 it2 = it2_end;
422 it1 = it1_end;
423 }
424#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
425 return const_iterator2 (*this, it1.index (), it2.index ());
426#else
427#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
428 return const_iterator2 (*this, it1, it2, it1 != it1_end ? *it1 : value_type/*zero*/());
429#else
430 return const_iterator2 (*this, it1, it2);
431#endif
432#endif
433 }
434
435 // Iterators enhance the iterators of the referenced expressions
436 // with the binary functor.
437
438#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
439 class const_iterator1:
440 public container_const_reference<vector_matrix_binary>,
441 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
442 typename E2::const_iterator::iterator_category>::iterator_category>::template
443 iterator_base<const_iterator1, value_type>::type {
444 public:
445 typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
446 typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
447 typedef typename vector_matrix_binary::difference_type difference_type;
448 typedef typename vector_matrix_binary::value_type value_type;
449 typedef typename vector_matrix_binary::const_reference reference;
450 typedef typename vector_matrix_binary::const_pointer pointer;
451
452 typedef const_iterator2 dual_iterator_type;
453 typedef const_reverse_iterator2 dual_reverse_iterator_type;
454
455 // Construction and destruction
456#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
457 BOOST_UBLAS_INLINE
458 const_iterator1 ():
459 container_const_reference<self_type> (), it1_ (), it2_ (), t2_ () {}
460 BOOST_UBLAS_INLINE
461 const_iterator1 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2, value_type t2):
462 container_const_reference<self_type> (vmb), it1_ (it1), it2_ (it2), t2_ (t2) {}
463#else
464 BOOST_UBLAS_INLINE
465 const_iterator1 ():
466 container_const_reference<self_type> (), it1_ (), it2_ () {}
467 BOOST_UBLAS_INLINE
468 const_iterator1 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
469 container_const_reference<self_type> (vmb), it1_ (it1), it2_ (it2) {}
470#endif
471
472 // Arithmetic
473 BOOST_UBLAS_INLINE
474 const_iterator1 &operator ++ () {
475 ++ it1_;
476 return *this;
477 }
478 BOOST_UBLAS_INLINE
479 const_iterator1 &operator -- () {
480 -- it1_;
481 return *this;
482 }
483 BOOST_UBLAS_INLINE
484 const_iterator1 &operator += (difference_type n) {
485 it1_ += n;
486 return *this;
487 }
488 BOOST_UBLAS_INLINE
489 const_iterator1 &operator -= (difference_type n) {
490 it1_ -= n;
491 return *this;
492 }
493 BOOST_UBLAS_INLINE
494 difference_type operator - (const const_iterator1 &it) const {
495 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
496 BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
497 return it1_ - it.it1_;
498 }
499
500 // Dereference
501 BOOST_UBLAS_INLINE
502 const_reference operator * () const {
503#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
504 return functor_type::apply (*it1_, t2_);
505#else
506 return functor_type::apply (*it1_, *it2_);
507#endif
508 }
509 BOOST_UBLAS_INLINE
510 const_reference operator [] (difference_type n) const {
511 return *(*this + n);
512 }
513
514#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
515 BOOST_UBLAS_INLINE
516#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
517 typename self_type::
518#endif
519 const_iterator2 begin () const {
520 return (*this) ().find2 (1, index1 (), 0);
521 }
522 BOOST_UBLAS_INLINE
523#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
524 typename self_type::
525#endif
526 const_iterator2 cbegin () const {
527 return begin ();
528 }
529 BOOST_UBLAS_INLINE
530#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
531 typename self_type::
532#endif
533 const_iterator2 end () const {
534 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
535 }
536 BOOST_UBLAS_INLINE
537#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
538 typename self_type::
539#endif
540 const_iterator2 cend () const {
541 return end ();
542 }
543 BOOST_UBLAS_INLINE
544#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
545 typename self_type::
546#endif
547 const_reverse_iterator2 rbegin () const {
548 return const_reverse_iterator2 (end ());
549 }
550 BOOST_UBLAS_INLINE
551#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
552 typename self_type::
553#endif
554 const_reverse_iterator2 crbegin () const {
555 return rbegin ();
556 }
557 BOOST_UBLAS_INLINE
558#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
559 typename self_type::
560#endif
561 const_reverse_iterator2 rend () const {
562 return const_reverse_iterator2 (begin ());
563 }
564 BOOST_UBLAS_INLINE
565#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
566 typename self_type::
567#endif
568 const_reverse_iterator2 crend () const {
569 return rend ();
570 }
571#endif
572
573 // Indices
574 BOOST_UBLAS_INLINE
575 size_type index1 () const {
576 return it1_.index ();
577 }
578 BOOST_UBLAS_INLINE
579 size_type index2 () const {
580 return it2_.index ();
581 }
582
583 // Assignment
584 BOOST_UBLAS_INLINE
585 const_iterator1 &operator = (const const_iterator1 &it) {
586 container_const_reference<self_type>::assign (&it ());
587 it1_ = it.it1_;
588 it2_ = it.it2_;
589#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
590 t2_ = it.t2_;
591#endif
592 return *this;
593 }
594
595 // Comparison
596 BOOST_UBLAS_INLINE
597 bool operator == (const const_iterator1 &it) const {
598 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
599 BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
600 return it1_ == it.it1_;
601 }
602 BOOST_UBLAS_INLINE
603 bool operator < (const const_iterator1 &it) const {
604 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
605 BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
606 return it1_ < it.it1_;
607 }
608
609 private:
610#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
611 const_subiterator1_type it1_;
612 // Mutable due to assignment
613 /* const */ const_subiterator2_type it2_;
614 value_type t2_;
615#else
616 const_subiterator1_type it1_;
617 const_subiterator2_type it2_;
618#endif
619 };
620#endif
621
622 BOOST_UBLAS_INLINE
623 const_iterator1 begin1 () const {
624 return find1 (0, 0, 0);
625 }
626 BOOST_UBLAS_INLINE
627 const_iterator1 cbegin1 () const {
628 return begin1 ();
629 }
630 BOOST_UBLAS_INLINE
631 const_iterator1 end1 () const {
632 return find1 (0, size1 (), 0);
633 }
634 BOOST_UBLAS_INLINE
635 const_iterator1 cend1 () const {
636 return end1 ();
637 }
638
639#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
640 class const_iterator2:
641 public container_const_reference<vector_matrix_binary>,
642 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
643 typename E2::const_iterator::iterator_category>::iterator_category>::template
644 iterator_base<const_iterator2, value_type>::type {
645 public:
646 typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
647 typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
648 typedef typename vector_matrix_binary::difference_type difference_type;
649 typedef typename vector_matrix_binary::value_type value_type;
650 typedef typename vector_matrix_binary::const_reference reference;
651 typedef typename vector_matrix_binary::const_pointer pointer;
652
653 typedef const_iterator1 dual_iterator_type;
654 typedef const_reverse_iterator1 dual_reverse_iterator_type;
655
656 // Construction and destruction
657#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
658 BOOST_UBLAS_INLINE
659 const_iterator2 ():
660 container_const_reference<self_type> (), it1_ (), it2_ (), t1_ () {}
661 BOOST_UBLAS_INLINE
662 const_iterator2 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2, value_type t1):
663 container_const_reference<self_type> (vmb), it1_ (it1), it2_ (it2), t1_ (t1) {}
664#else
665 BOOST_UBLAS_INLINE
666 const_iterator2 ():
667 container_const_reference<self_type> (), it1_ (), it2_ () {}
668 BOOST_UBLAS_INLINE
669 const_iterator2 (const self_type &vmb, const const_subiterator1_type &it1, const const_subiterator2_type &it2):
670 container_const_reference<self_type> (vmb), it1_ (it1), it2_ (it2) {}
671#endif
672
673 // Arithmetic
674 BOOST_UBLAS_INLINE
675 const_iterator2 &operator ++ () {
676 ++ it2_;
677 return *this;
678 }
679 BOOST_UBLAS_INLINE
680 const_iterator2 &operator -- () {
681 -- it2_;
682 return *this;
683 }
684 BOOST_UBLAS_INLINE
685 const_iterator2 &operator += (difference_type n) {
686 it2_ += n;
687 return *this;
688 }
689 BOOST_UBLAS_INLINE
690 const_iterator2 &operator -= (difference_type n) {
691 it2_ -= n;
692 return *this;
693 }
694 BOOST_UBLAS_INLINE
695 difference_type operator - (const const_iterator2 &it) const {
696 BOOST_UBLAS_CHECK ((*this) ().same_closure(it ()), external_logic ());
697 BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
698 return it2_ - it.it2_;
699 }
700
701 // Dereference
702 BOOST_UBLAS_INLINE
703 const_reference operator * () const {
704#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
705 return functor_type::apply (t1_, *it2_);
706#else
707 return functor_type::apply (*it1_, *it2_);
708#endif
709 }
710 BOOST_UBLAS_INLINE
711 const_reference operator [] (difference_type n) const {
712 return *(*this + n);
713 }
714
715#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
716 BOOST_UBLAS_INLINE
717#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
718 typename self_type::
719#endif
720 const_iterator1 begin () const {
721 return (*this) ().find1 (1, 0, index2 ());
722 }
723 BOOST_UBLAS_INLINE
724#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
725 typename self_type::
726#endif
727 const_iterator1 cbegin () const {
728 return begin ();
729 }
730 BOOST_UBLAS_INLINE
731#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
732 typename self_type::
733#endif
734 const_iterator1 end () const {
735 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
736 }
737 BOOST_UBLAS_INLINE
738#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
739 typename self_type::
740#endif
741 const_iterator1 cend () const {
742 return end ();
743 }
744 BOOST_UBLAS_INLINE
745#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
746 typename self_type::
747#endif
748 const_reverse_iterator1 rbegin () const {
749 return const_reverse_iterator1 (end ());
750 }
751 BOOST_UBLAS_INLINE
752#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
753 typename self_type::
754#endif
755 const_reverse_iterator1 crbegin () const {
756 return rbegin ();
757 }
758 BOOST_UBLAS_INLINE
759#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
760 typename self_type::
761#endif
762 const_reverse_iterator1 rend () const {
763 return const_reverse_iterator1 (begin ());
764 }
765 BOOST_UBLAS_INLINE
766#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
767 typename self_type::
768#endif
769 const_reverse_iterator1 crend () const {
770 return rend ();
771 }
772#endif
773
774 // Indices
775 BOOST_UBLAS_INLINE
776 size_type index1 () const {
777 return it1_.index ();
778 }
779 BOOST_UBLAS_INLINE
780 size_type index2 () const {
781 return it2_.index ();
782 }
783
784 // Assignment
785 BOOST_UBLAS_INLINE
786 const_iterator2 &operator = (const const_iterator2 &it) {
787 container_const_reference<self_type>::assign (&it ());
788 it1_ = it.it1_;
789 it2_ = it.it2_;
790#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
791 t1_ = it.t1_;
792#endif
793 return *this;
794 }
795
796 // Comparison
797 BOOST_UBLAS_INLINE
798 bool operator == (const const_iterator2 &it) const {
799 BOOST_UBLAS_CHECK ((*this) ().same_closure( it ()), external_logic ());
800 BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
801 return it2_ == it.it2_;
802 }
803 BOOST_UBLAS_INLINE
804 bool operator < (const const_iterator2 &it) const {
805 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
806 BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
807 return it2_ < it.it2_;
808 }
809
810 private:
811#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
812 // Mutable due to assignment
813 /* const */ const_subiterator1_type it1_;
814 const_subiterator2_type it2_;
815 value_type t1_;
816#else
817 const_subiterator1_type it1_;
818 const_subiterator2_type it2_;
819#endif
820 };
821#endif
822
823 BOOST_UBLAS_INLINE
824 const_iterator2 begin2 () const {
825 return find2 (0, 0, 0);
826 }
827 BOOST_UBLAS_INLINE
828 const_iterator2 cbegin2 () const {
829 return begin2 ();
830 }
831 BOOST_UBLAS_INLINE
832 const_iterator2 end2 () const {
833 return find2 (0, 0, size2 ());
834 }
835 BOOST_UBLAS_INLINE
836 const_iterator2 cend2 () const {
837 return end2 ();
838 }
839
840 // Reverse iterators
841
842 BOOST_UBLAS_INLINE
843 const_reverse_iterator1 rbegin1 () const {
844 return const_reverse_iterator1 (end1 ());
845 }
846 BOOST_UBLAS_INLINE
847 const_reverse_iterator1 crbegin1 () const {
848 return rbegin1 ();
849 }
850 BOOST_UBLAS_INLINE
851 const_reverse_iterator1 rend1 () const {
852 return const_reverse_iterator1 (begin1 ());
853 }
854 BOOST_UBLAS_INLINE
855 const_reverse_iterator1 crend1 () const {
856 return rend1 ();
857 }
858 BOOST_UBLAS_INLINE
859 const_reverse_iterator2 rbegin2 () const {
860 return const_reverse_iterator2 (end2 ());
861 }
862 BOOST_UBLAS_INLINE
863 const_reverse_iterator2 crbegin2 () const {
864 return rbegin2 ();
865 }
866 BOOST_UBLAS_INLINE
867 const_reverse_iterator2 rend2 () const {
868 return const_reverse_iterator2 (begin2 ());
869 }
870 BOOST_UBLAS_INLINE
871 const_reverse_iterator2 crend2 () const {
872 return rend2 ();
873 }
874
875 private:
876 expression1_closure_type e1_;
877 expression2_closure_type e2_;
878 };
879
880 template<class E1, class E2, class F>
881 struct vector_matrix_binary_traits {
882 typedef vector_matrix_binary<E1, E2, F> expression_type;
883#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
884 typedef expression_type result_type;
885#else
886 // ISSUE matrix is arbitary temporary type
887 typedef matrix<typename F::value_type> result_type;
888#endif
889 };
890
891 // (outer_prod (v1, v2)) [i] [j] = v1 [i] * v2 [j]
892 template<class E1, class E2>
893 BOOST_UBLAS_INLINE
894 typename vector_matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::result_type
895 outer_prod (const vector_expression<E1> &e1,
896 const vector_expression<E2> &e2) {
897 BOOST_STATIC_ASSERT (E1::complexity == 0 && E2::complexity == 0);
898 typedef typename vector_matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
899 return expression_type (e1 (), e2 ());
900 }
901
902 template<class E, class F>
903 class matrix_unary1:
904 public matrix_expression<matrix_unary1<E, F> > {
905
906 typedef E expression_type;
907 typedef F functor_type;
908 public:
909 typedef typename E::const_closure_type expression_closure_type;
910 private:
911 typedef matrix_unary1<E, F> self_type;
912 public:
913#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
914 using matrix_expression<self_type>::operator ();
915#endif
916 typedef typename E::size_type size_type;
917 typedef typename E::difference_type difference_type;
918 typedef typename F::result_type value_type;
919 typedef value_type const_reference;
920 typedef const_reference reference;
921 typedef const self_type const_closure_type;
922 typedef const_closure_type closure_type;
923 typedef typename E::orientation_category orientation_category;
924 typedef unknown_storage_tag storage_category;
925
926 // Construction and destruction
927 BOOST_UBLAS_INLINE
928 explicit matrix_unary1 (const expression_type &e):
929 e_ (e) {}
930
931 // Accessors
932 BOOST_UBLAS_INLINE
933 size_type size1 () const {
934 return e_.size1 ();
935 }
936 BOOST_UBLAS_INLINE
937 size_type size2 () const {
938 return e_.size2 ();
939 }
940
941 public:
942 // Expression accessors
943 BOOST_UBLAS_INLINE
944 const expression_closure_type &expression () const {
945 return e_;
946 }
947
948 public:
949 // Element access
950 BOOST_UBLAS_INLINE
951 const_reference operator () (size_type i, size_type j) const {
952 return functor_type::apply (e_ (i, j));
953 }
954
955 // Closure comparison
956 BOOST_UBLAS_INLINE
957 bool same_closure (const matrix_unary1 &mu1) const {
958 return (*this).expression ().same_closure (mu1.expression ());
959 }
960
961 // Iterator types
962 private:
963 typedef typename E::const_iterator1 const_subiterator1_type;
964 typedef typename E::const_iterator2 const_subiterator2_type;
965 typedef const value_type *const_pointer;
966
967 public:
968#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
969 typedef indexed_const_iterator1<const_closure_type, typename const_subiterator1_type::iterator_category> const_iterator1;
970 typedef const_iterator1 iterator1;
971 typedef indexed_const_iterator2<const_closure_type, typename const_subiterator2_type::iterator_category> const_iterator2;
972 typedef const_iterator2 iterator2;
973#else
974 class const_iterator1;
975 typedef const_iterator1 iterator1;
976 class const_iterator2;
977 typedef const_iterator2 iterator2;
978#endif
979 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
980 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
981
982 // Element lookup
983 BOOST_UBLAS_INLINE
984 const_iterator1 find1 (int rank, size_type i, size_type j) const {
985 const_subiterator1_type it1 (e_.find1 (rank, i, j));
986#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
987 return const_iterator1 (*this, it1.index1 (), it1.index2 ());
988#else
989 return const_iterator1 (*this, it1);
990#endif
991 }
992 BOOST_UBLAS_INLINE
993 const_iterator2 find2 (int rank, size_type i, size_type j) const {
994 const_subiterator2_type it2 (e_.find2 (rank, i, j));
995#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
996 return const_iterator2 (*this, it2.index1 (), it2.index2 ());
997#else
998 return const_iterator2 (*this, it2);
999#endif
1000 }
1001
1002 // Iterators enhance the iterators of the referenced expression
1003 // with the unary functor.
1004
1005#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1006 class const_iterator1:
1007 public container_const_reference<matrix_unary1>,
1008 public iterator_base_traits<typename E::const_iterator1::iterator_category>::template
1009 iterator_base<const_iterator1, value_type>::type {
1010 public:
1011 typedef typename E::const_iterator1::iterator_category iterator_category;
1012 typedef typename matrix_unary1::difference_type difference_type;
1013 typedef typename matrix_unary1::value_type value_type;
1014 typedef typename matrix_unary1::const_reference reference;
1015 typedef typename matrix_unary1::const_pointer pointer;
1016
1017 typedef const_iterator2 dual_iterator_type;
1018 typedef const_reverse_iterator2 dual_reverse_iterator_type;
1019
1020 // Construction and destruction
1021 BOOST_UBLAS_INLINE
1022 const_iterator1 ():
1023 container_const_reference<self_type> (), it_ () {}
1024 BOOST_UBLAS_INLINE
1025 const_iterator1 (const self_type &mu, const const_subiterator1_type &it):
1026 container_const_reference<self_type> (mu), it_ (it) {}
1027
1028 // Arithmetic
1029 BOOST_UBLAS_INLINE
1030 const_iterator1 &operator ++ () {
1031 ++ it_;
1032 return *this;
1033 }
1034 BOOST_UBLAS_INLINE
1035 const_iterator1 &operator -- () {
1036 -- it_;
1037 return *this;
1038 }
1039 BOOST_UBLAS_INLINE
1040 const_iterator1 &operator += (difference_type n) {
1041 it_ += n;
1042 return *this;
1043 }
1044 BOOST_UBLAS_INLINE
1045 const_iterator1 &operator -= (difference_type n) {
1046 it_ -= n;
1047 return *this;
1048 }
1049 BOOST_UBLAS_INLINE
1050 difference_type operator - (const const_iterator1 &it) const {
1051 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1052 return it_ - it.it_;
1053 }
1054
1055 // Dereference
1056 BOOST_UBLAS_INLINE
1057 const_reference operator * () const {
1058 return functor_type::apply (*it_);
1059 }
1060 BOOST_UBLAS_INLINE
1061 const_reference operator [] (difference_type n) const {
1062 return *(*this + n);
1063 }
1064
1065#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1066 BOOST_UBLAS_INLINE
1067#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1068 typename self_type::
1069#endif
1070 const_iterator2 begin () const {
1071 return (*this) ().find2 (1, index1 (), 0);
1072 }
1073 BOOST_UBLAS_INLINE
1074#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1075 typename self_type::
1076#endif
1077 const_iterator2 cbegin () const {
1078 return begin ();
1079 }
1080 BOOST_UBLAS_INLINE
1081#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1082 typename self_type::
1083#endif
1084 const_iterator2 end () const {
1085 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
1086 }
1087 BOOST_UBLAS_INLINE
1088#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1089 typename self_type::
1090#endif
1091 const_iterator2 cend () const {
1092 return end ();
1093 }
1094 BOOST_UBLAS_INLINE
1095#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1096 typename self_type::
1097#endif
1098 const_reverse_iterator2 rbegin () const {
1099 return const_reverse_iterator2 (end ());
1100 }
1101 BOOST_UBLAS_INLINE
1102#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1103 typename self_type::
1104#endif
1105 const_reverse_iterator2 crbegin () const {
1106 return rbegin ();
1107 }
1108 BOOST_UBLAS_INLINE
1109#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1110 typename self_type::
1111#endif
1112 const_reverse_iterator2 rend () const {
1113 return const_reverse_iterator2 (begin ());
1114 }
1115 BOOST_UBLAS_INLINE
1116#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1117 typename self_type::
1118#endif
1119 const_reverse_iterator2 crend () const {
1120 return rend ();
1121 }
1122#endif
1123
1124 // Indices
1125 BOOST_UBLAS_INLINE
1126 size_type index1 () const {
1127 return it_.index1 ();
1128 }
1129 BOOST_UBLAS_INLINE
1130 size_type index2 () const {
1131 return it_.index2 ();
1132 }
1133
1134 // Assignment
1135 BOOST_UBLAS_INLINE
1136 const_iterator1 &operator = (const const_iterator1 &it) {
1137 container_const_reference<self_type>::assign (&it ());
1138 it_ = it.it_;
1139 return *this;
1140 }
1141
1142 // Comparison
1143 BOOST_UBLAS_INLINE
1144 bool operator == (const const_iterator1 &it) const {
1145 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1146 return it_ == it.it_;
1147 }
1148 BOOST_UBLAS_INLINE
1149 bool operator < (const const_iterator1 &it) const {
1150 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1151 return it_ < it.it_;
1152 }
1153
1154 private:
1155 const_subiterator1_type it_;
1156 };
1157#endif
1158
1159 BOOST_UBLAS_INLINE
1160 const_iterator1 begin1 () const {
1161 return find1 (0, 0, 0);
1162 }
1163 BOOST_UBLAS_INLINE
1164 const_iterator1 cbegin1 () const {
1165 return begin1 ();
1166 }
1167 BOOST_UBLAS_INLINE
1168 const_iterator1 end1 () const {
1169 return find1 (0, size1 (), 0);
1170 }
1171 BOOST_UBLAS_INLINE
1172 const_iterator1 cend1 () const {
1173 return end1 ();
1174 }
1175
1176#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1177 class const_iterator2:
1178 public container_const_reference<matrix_unary1>,
1179 public iterator_base_traits<typename E::const_iterator2::iterator_category>::template
1180 iterator_base<const_iterator2, value_type>::type {
1181 public:
1182 typedef typename E::const_iterator2::iterator_category iterator_category;
1183 typedef typename matrix_unary1::difference_type difference_type;
1184 typedef typename matrix_unary1::value_type value_type;
1185 typedef typename matrix_unary1::const_reference reference;
1186 typedef typename matrix_unary1::const_pointer pointer;
1187
1188 typedef const_iterator1 dual_iterator_type;
1189 typedef const_reverse_iterator1 dual_reverse_iterator_type;
1190
1191 // Construction and destruction
1192 BOOST_UBLAS_INLINE
1193 const_iterator2 ():
1194 container_const_reference<self_type> (), it_ () {}
1195 BOOST_UBLAS_INLINE
1196 const_iterator2 (const self_type &mu, const const_subiterator2_type &it):
1197 container_const_reference<self_type> (mu), it_ (it) {}
1198
1199 // Arithmetic
1200 BOOST_UBLAS_INLINE
1201 const_iterator2 &operator ++ () {
1202 ++ it_;
1203 return *this;
1204 }
1205 BOOST_UBLAS_INLINE
1206 const_iterator2 &operator -- () {
1207 -- it_;
1208 return *this;
1209 }
1210 BOOST_UBLAS_INLINE
1211 const_iterator2 &operator += (difference_type n) {
1212 it_ += n;
1213 return *this;
1214 }
1215 BOOST_UBLAS_INLINE
1216 const_iterator2 &operator -= (difference_type n) {
1217 it_ -= n;
1218 return *this;
1219 }
1220 BOOST_UBLAS_INLINE
1221 difference_type operator - (const const_iterator2 &it) const {
1222 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1223 return it_ - it.it_;
1224 }
1225
1226 // Dereference
1227 BOOST_UBLAS_INLINE
1228 const_reference operator * () const {
1229 return functor_type::apply (*it_);
1230 }
1231 BOOST_UBLAS_INLINE
1232 const_reference operator [] (difference_type n) const {
1233 return *(*this + n);
1234 }
1235
1236#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1237 BOOST_UBLAS_INLINE
1238#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1239 typename self_type::
1240#endif
1241 const_iterator1 begin () const {
1242 return (*this) ().find1 (1, 0, index2 ());
1243 }
1244 BOOST_UBLAS_INLINE
1245#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1246 typename self_type::
1247#endif
1248 const_iterator1 cbegin () const {
1249 return begin ();
1250 }
1251 BOOST_UBLAS_INLINE
1252#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1253 typename self_type::
1254#endif
1255 const_iterator1 end () const {
1256 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
1257 }
1258 BOOST_UBLAS_INLINE
1259#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1260 typename self_type::
1261#endif
1262 const_iterator1 cend () const {
1263 return end ();
1264 }
1265 BOOST_UBLAS_INLINE
1266#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1267 typename self_type::
1268#endif
1269 const_reverse_iterator1 rbegin () const {
1270 return const_reverse_iterator1 (end ());
1271 }
1272 BOOST_UBLAS_INLINE
1273#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1274 typename self_type::
1275#endif
1276 const_reverse_iterator1 crbegin () const {
1277 return rbegin ();
1278 }
1279 BOOST_UBLAS_INLINE
1280#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1281 typename self_type::
1282#endif
1283 const_reverse_iterator1 rend () const {
1284 return const_reverse_iterator1 (begin ());
1285 }
1286 BOOST_UBLAS_INLINE
1287#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1288 typename self_type::
1289#endif
1290 const_reverse_iterator1 crend () const {
1291 return rend ();
1292 }
1293#endif
1294
1295 // Indices
1296 BOOST_UBLAS_INLINE
1297 size_type index1 () const {
1298 return it_.index1 ();
1299 }
1300 BOOST_UBLAS_INLINE
1301 size_type index2 () const {
1302 return it_.index2 ();
1303 }
1304
1305 // Assignment
1306 BOOST_UBLAS_INLINE
1307 const_iterator2 &operator = (const const_iterator2 &it) {
1308 container_const_reference<self_type>::assign (&it ());
1309 it_ = it.it_;
1310 return *this;
1311 }
1312
1313 // Comparison
1314 BOOST_UBLAS_INLINE
1315 bool operator == (const const_iterator2 &it) const {
1316 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1317 return it_ == it.it_;
1318 }
1319 BOOST_UBLAS_INLINE
1320 bool operator < (const const_iterator2 &it) const {
1321 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1322 return it_ < it.it_;
1323 }
1324
1325 private:
1326 const_subiterator2_type it_;
1327 };
1328#endif
1329
1330 BOOST_UBLAS_INLINE
1331 const_iterator2 begin2 () const {
1332 return find2 (0, 0, 0);
1333 }
1334 BOOST_UBLAS_INLINE
1335 const_iterator2 cbegin2 () const {
1336 return begin2 ();
1337 }
1338 BOOST_UBLAS_INLINE
1339 const_iterator2 end2 () const {
1340 return find2 (0, 0, size2 ());
1341 }
1342 BOOST_UBLAS_INLINE
1343 const_iterator2 cend2 () const {
1344 return end2 ();
1345 }
1346
1347 // Reverse iterators
1348
1349 BOOST_UBLAS_INLINE
1350 const_reverse_iterator1 rbegin1 () const {
1351 return const_reverse_iterator1 (end1 ());
1352 }
1353 BOOST_UBLAS_INLINE
1354 const_reverse_iterator1 crbegin1 () const {
1355 return rbegin1 ();
1356 }
1357 BOOST_UBLAS_INLINE
1358 const_reverse_iterator1 rend1 () const {
1359 return const_reverse_iterator1 (begin1 ());
1360 }
1361 BOOST_UBLAS_INLINE
1362 const_reverse_iterator1 crend1 () const {
1363 return rend1 ();
1364 }
1365
1366 BOOST_UBLAS_INLINE
1367 const_reverse_iterator2 rbegin2 () const {
1368 return const_reverse_iterator2 (end2 ());
1369 }
1370 BOOST_UBLAS_INLINE
1371 const_reverse_iterator2 crbegin2 () const {
1372 return rbegin2 ();
1373 }
1374 BOOST_UBLAS_INLINE
1375 const_reverse_iterator2 rend2 () const {
1376 return const_reverse_iterator2 (begin2 ());
1377 }
1378 BOOST_UBLAS_INLINE
1379 const_reverse_iterator2 crend2 () const {
1380 return rend2 ();
1381 }
1382
1383 private:
1384 expression_closure_type e_;
1385 };
1386
1387 template<class E, class F>
1388 struct matrix_unary1_traits {
1389 typedef matrix_unary1<E, F> expression_type;
1390#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
1391 typedef expression_type result_type;
1392#else
1393 typedef typename E::matrix_temporary_type result_type;
1394#endif
1395 };
1396
1397 // (- m) [i] [j] = - m [i] [j]
1398 template<class E>
1399 BOOST_UBLAS_INLINE
1400 typename matrix_unary1_traits<E, scalar_negate<typename E::value_type> >::result_type
1401 operator - (const matrix_expression<E> &e) {
1402 typedef typename matrix_unary1_traits<E, scalar_negate<typename E::value_type> >::expression_type expression_type;
1403 return expression_type (e ());
1404 }
1405
1406 // (conj m) [i] [j] = conj (m [i] [j])
1407 template<class E>
1408 BOOST_UBLAS_INLINE
1409 typename matrix_unary1_traits<E, scalar_conj<typename E::value_type> >::result_type
1410 conj (const matrix_expression<E> &e) {
1411 typedef typename matrix_unary1_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
1412 return expression_type (e ());
1413 }
1414
1415 // (real m) [i] [j] = real (m [i] [j])
1416 template<class E>
1417 BOOST_UBLAS_INLINE
1418 typename matrix_unary1_traits<E, scalar_real<typename E::value_type> >::result_type
1419 real (const matrix_expression<E> &e) {
1420 typedef typename matrix_unary1_traits<E, scalar_real<typename E::value_type> >::expression_type expression_type;
1421 return expression_type (e ());
1422 }
1423
1424 // (imag m) [i] [j] = imag (m [i] [j])
1425 template<class E>
1426 BOOST_UBLAS_INLINE
1427 typename matrix_unary1_traits<E, scalar_imag<typename E::value_type> >::result_type
1428 imag (const matrix_expression<E> &e) {
1429 typedef typename matrix_unary1_traits<E, scalar_imag<typename E::value_type> >::expression_type expression_type;
1430 return expression_type (e ());
1431 }
1432
1433 template<class E, class F>
1434 class matrix_unary2:
1435 public matrix_expression<matrix_unary2<E, F> > {
1436
1437 typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<typename E::value_type> >,
1438 E,
1439 const E>::type expression_type;
1440 typedef F functor_type;
1441 public:
1442 typedef typename boost::mpl::if_<boost::is_const<expression_type>,
1443 typename E::const_closure_type,
1444 typename E::closure_type>::type expression_closure_type;
1445 private:
1446 typedef matrix_unary2<E, F> self_type;
1447 public:
1448#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
1449 using matrix_expression<self_type>::operator ();
1450#endif
1451 typedef typename E::size_type size_type;
1452 typedef typename E::difference_type difference_type;
1453 typedef typename F::result_type value_type;
1454 typedef value_type const_reference;
1455 typedef typename boost::mpl::if_<boost::is_same<F, scalar_identity<value_type> >,
1456 typename E::reference,
1457 value_type>::type reference;
1458
1459 typedef const self_type const_closure_type;
1460 typedef self_type closure_type;
1461 typedef typename boost::mpl::if_<boost::is_same<typename E::orientation_category,
1462 row_major_tag>,
1463 column_major_tag,
1464 typename boost::mpl::if_<boost::is_same<typename E::orientation_category,
1465 column_major_tag>,
1466 row_major_tag,
1467 typename E::orientation_category>::type>::type orientation_category;
1468 typedef typename E::storage_category storage_category;
1469
1470 // Construction and destruction
1471 BOOST_UBLAS_INLINE
1472 // matrix_unary2 may be used as mutable expression -
1473 // this is the only non const expression constructor
1474 explicit matrix_unary2 (expression_type &e):
1475 e_ (e) {}
1476
1477 // Accessors
1478 BOOST_UBLAS_INLINE
1479 size_type size1 () const {
1480 return e_.size2 ();
1481 }
1482 BOOST_UBLAS_INLINE
1483 size_type size2 () const {
1484 return e_.size1 ();
1485 }
1486
1487 public:
1488 // Expression accessors
1489 BOOST_UBLAS_INLINE
1490 const expression_closure_type &expression () const {
1491 return e_;
1492 }
1493
1494 public:
1495 // Element access
1496 BOOST_UBLAS_INLINE
1497 const_reference operator () (size_type i, size_type j) const {
1498 return functor_type::apply (e_ (j, i));
1499 }
1500 BOOST_UBLAS_INLINE
1501 reference operator () (size_type i, size_type j) {
1502 BOOST_STATIC_ASSERT ((boost::is_same<functor_type, scalar_identity<value_type > >::value));
1503 return e_ (j, i);
1504 }
1505
1506 // Closure comparison
1507 BOOST_UBLAS_INLINE
1508 bool same_closure (const matrix_unary2 &mu2) const {
1509 return (*this).expression ().same_closure (mu2.expression ());
1510 }
1511
1512 // Iterator types
1513 private:
1514 typedef typename E::const_iterator1 const_subiterator2_type;
1515 typedef typename E::const_iterator2 const_subiterator1_type;
1516 typedef const value_type *const_pointer;
1517
1518 public:
1519#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
1520 typedef indexed_const_iterator1<const_closure_type, typename const_subiterator1_type::iterator_category> const_iterator1;
1521 typedef const_iterator1 iterator1;
1522 typedef indexed_const_iterator2<const_closure_type, typename const_subiterator2_type::iterator_category> const_iterator2;
1523 typedef const_iterator2 iterator2;
1524#else
1525 class const_iterator1;
1526 typedef const_iterator1 iterator1;
1527 class const_iterator2;
1528 typedef const_iterator2 iterator2;
1529#endif
1530 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
1531 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
1532
1533 // Element lookup
1534 BOOST_UBLAS_INLINE
1535 const_iterator1 find1 (int rank, size_type i, size_type j) const {
1536 const_subiterator1_type it1 (e_.find2 (rank, j, i));
1537#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
1538 return const_iterator1 (*this, it1.index2 (), it1.index1 ());
1539#else
1540 return const_iterator1 (*this, it1);
1541#endif
1542 }
1543 BOOST_UBLAS_INLINE
1544 const_iterator2 find2 (int rank, size_type i, size_type j) const {
1545 const_subiterator2_type it2 (e_.find1 (rank, j, i));
1546#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
1547 return const_iterator2 (*this, it2.index2 (), it2.index1 ());
1548#else
1549 return const_iterator2 (*this, it2);
1550#endif
1551 }
1552
1553 // Iterators enhance the iterators of the referenced expression
1554 // with the unary functor.
1555
1556#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1557 class const_iterator1:
1558 public container_const_reference<matrix_unary2>,
1559 public iterator_base_traits<typename E::const_iterator2::iterator_category>::template
1560 iterator_base<const_iterator1, value_type>::type {
1561 public:
1562 typedef typename E::const_iterator2::iterator_category iterator_category;
1563 typedef typename matrix_unary2::difference_type difference_type;
1564 typedef typename matrix_unary2::value_type value_type;
1565 typedef typename matrix_unary2::const_reference reference;
1566 typedef typename matrix_unary2::const_pointer pointer;
1567
1568 typedef const_iterator2 dual_iterator_type;
1569 typedef const_reverse_iterator2 dual_reverse_iterator_type;
1570
1571 // Construction and destruction
1572 BOOST_UBLAS_INLINE
1573 const_iterator1 ():
1574 container_const_reference<self_type> (), it_ () {}
1575 BOOST_UBLAS_INLINE
1576 const_iterator1 (const self_type &mu, const const_subiterator1_type &it):
1577 container_const_reference<self_type> (mu), it_ (it) {}
1578
1579 // Arithmetic
1580 BOOST_UBLAS_INLINE
1581 const_iterator1 &operator ++ () {
1582 ++ it_;
1583 return *this;
1584 }
1585 BOOST_UBLAS_INLINE
1586 const_iterator1 &operator -- () {
1587 -- it_;
1588 return *this;
1589 }
1590 BOOST_UBLAS_INLINE
1591 const_iterator1 &operator += (difference_type n) {
1592 it_ += n;
1593 return *this;
1594 }
1595 BOOST_UBLAS_INLINE
1596 const_iterator1 &operator -= (difference_type n) {
1597 it_ -= n;
1598 return *this;
1599 }
1600 BOOST_UBLAS_INLINE
1601 difference_type operator - (const const_iterator1 &it) const {
1602 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1603 return it_ - it.it_;
1604 }
1605
1606 // Dereference
1607 BOOST_UBLAS_INLINE
1608 const_reference operator * () const {
1609 return functor_type::apply (*it_);
1610 }
1611 BOOST_UBLAS_INLINE
1612 const_reference operator [] (difference_type n) const {
1613 return *(*this + n);
1614 }
1615
1616#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1617 BOOST_UBLAS_INLINE
1618#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1619 typename self_type::
1620#endif
1621 const_iterator2 begin () const {
1622 return (*this) ().find2 (1, index1 (), 0);
1623 }
1624 BOOST_UBLAS_INLINE
1625#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1626 typename self_type::
1627#endif
1628 const_iterator2 cbegin () const {
1629 return begin ();
1630 }
1631 BOOST_UBLAS_INLINE
1632#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1633 typename self_type::
1634#endif
1635 const_iterator2 end () const {
1636 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
1637 }
1638 BOOST_UBLAS_INLINE
1639#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1640 typename self_type::
1641#endif
1642 const_iterator2 cend () const {
1643 return end ();
1644 }
1645 BOOST_UBLAS_INLINE
1646#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1647 typename self_type::
1648#endif
1649 const_reverse_iterator2 rbegin () const {
1650 return const_reverse_iterator2 (end ());
1651 }
1652 BOOST_UBLAS_INLINE
1653#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1654 typename self_type::
1655#endif
1656 const_reverse_iterator2 crbegin () const {
1657 return rbegin ();
1658 }
1659 BOOST_UBLAS_INLINE
1660#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1661 typename self_type::
1662#endif
1663 const_reverse_iterator2 rend () const {
1664 return const_reverse_iterator2 (begin ());
1665 }
1666 BOOST_UBLAS_INLINE
1667#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1668 typename self_type::
1669#endif
1670 const_reverse_iterator2 crend () const {
1671 return rend ();
1672 }
1673#endif
1674
1675 // Indices
1676 BOOST_UBLAS_INLINE
1677 size_type index1 () const {
1678 return it_.index2 ();
1679 }
1680 BOOST_UBLAS_INLINE
1681 size_type index2 () const {
1682 return it_.index1 ();
1683 }
1684
1685 // Assignment
1686 BOOST_UBLAS_INLINE
1687 const_iterator1 &operator = (const const_iterator1 &it) {
1688 container_const_reference<self_type>::assign (&it ());
1689 it_ = it.it_;
1690 return *this;
1691 }
1692
1693 // Comparison
1694 BOOST_UBLAS_INLINE
1695 bool operator == (const const_iterator1 &it) const {
1696 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1697 return it_ == it.it_;
1698 }
1699 BOOST_UBLAS_INLINE
1700 bool operator < (const const_iterator1 &it) const {
1701 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1702 return it_ < it.it_;
1703 }
1704
1705 private:
1706 const_subiterator1_type it_;
1707 };
1708#endif
1709
1710 BOOST_UBLAS_INLINE
1711 const_iterator1 begin1 () const {
1712 return find1 (0, 0, 0);
1713 }
1714 BOOST_UBLAS_INLINE
1715 const_iterator1 cbegin1 () const {
1716 return begin1 ();
1717 }
1718 BOOST_UBLAS_INLINE
1719 const_iterator1 end1 () const {
1720 return find1 (0, size1 (), 0);
1721 }
1722 BOOST_UBLAS_INLINE
1723 const_iterator1 cend1 () const {
1724 return end1 ();
1725 }
1726
1727#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1728 class const_iterator2:
1729 public container_const_reference<matrix_unary2>,
1730 public iterator_base_traits<typename E::const_iterator1::iterator_category>::template
1731 iterator_base<const_iterator2, value_type>::type {
1732 public:
1733 typedef typename E::const_iterator1::iterator_category iterator_category;
1734 typedef typename matrix_unary2::difference_type difference_type;
1735 typedef typename matrix_unary2::value_type value_type;
1736 typedef typename matrix_unary2::const_reference reference;
1737 typedef typename matrix_unary2::const_pointer pointer;
1738
1739 typedef const_iterator1 dual_iterator_type;
1740 typedef const_reverse_iterator1 dual_reverse_iterator_type;
1741
1742 // Construction and destruction
1743 BOOST_UBLAS_INLINE
1744 const_iterator2 ():
1745 container_const_reference<self_type> (), it_ () {}
1746 BOOST_UBLAS_INLINE
1747 const_iterator2 (const self_type &mu, const const_subiterator2_type &it):
1748 container_const_reference<self_type> (mu), it_ (it) {}
1749
1750 // Arithmetic
1751 BOOST_UBLAS_INLINE
1752 const_iterator2 &operator ++ () {
1753 ++ it_;
1754 return *this;
1755 }
1756 BOOST_UBLAS_INLINE
1757 const_iterator2 &operator -- () {
1758 -- it_;
1759 return *this;
1760 }
1761 BOOST_UBLAS_INLINE
1762 const_iterator2 &operator += (difference_type n) {
1763 it_ += n;
1764 return *this;
1765 }
1766 BOOST_UBLAS_INLINE
1767 const_iterator2 &operator -= (difference_type n) {
1768 it_ -= n;
1769 return *this;
1770 }
1771 BOOST_UBLAS_INLINE
1772 difference_type operator - (const const_iterator2 &it) const {
1773 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1774 return it_ - it.it_;
1775 }
1776
1777 // Dereference
1778 BOOST_UBLAS_INLINE
1779 const_reference operator * () const {
1780 return functor_type::apply (*it_);
1781 }
1782 BOOST_UBLAS_INLINE
1783 const_reference operator [] (difference_type n) const {
1784 return *(*this + n);
1785 }
1786
1787#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1788 BOOST_UBLAS_INLINE
1789#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1790 typename self_type::
1791#endif
1792 const_iterator1 begin () const {
1793 return (*this) ().find1 (1, 0, index2 ());
1794 }
1795 BOOST_UBLAS_INLINE
1796#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1797 typename self_type::
1798#endif
1799 const_iterator1 cbegin () const {
1800 return begin ();
1801 }
1802 BOOST_UBLAS_INLINE
1803#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1804 typename self_type::
1805#endif
1806 const_iterator1 end () const {
1807 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
1808 }
1809 BOOST_UBLAS_INLINE
1810#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1811 typename self_type::
1812#endif
1813 const_iterator1 cend () const {
1814 return end ();
1815 }
1816 BOOST_UBLAS_INLINE
1817#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1818 typename self_type::
1819#endif
1820 const_reverse_iterator1 rbegin () const {
1821 return const_reverse_iterator1 (end ());
1822 }
1823 BOOST_UBLAS_INLINE
1824#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1825 typename self_type::
1826#endif
1827 const_reverse_iterator1 crbegin () const {
1828 return rbegin ();
1829 }
1830 BOOST_UBLAS_INLINE
1831#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1832 typename self_type::
1833#endif
1834 const_reverse_iterator1 rend () const {
1835 return const_reverse_iterator1 (begin ());
1836 }
1837 BOOST_UBLAS_INLINE
1838#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1839 typename self_type::
1840#endif
1841 const_reverse_iterator1 crend () const {
1842 return rend ();
1843 }
1844#endif
1845
1846 // Indices
1847 BOOST_UBLAS_INLINE
1848 size_type index1 () const {
1849 return it_.index2 ();
1850 }
1851 BOOST_UBLAS_INLINE
1852 size_type index2 () const {
1853 return it_.index1 ();
1854 }
1855
1856 // Assignment
1857 BOOST_UBLAS_INLINE
1858 const_iterator2 &operator = (const const_iterator2 &it) {
1859 container_const_reference<self_type>::assign (&it ());
1860 it_ = it.it_;
1861 return *this;
1862 }
1863
1864 // Comparison
1865 BOOST_UBLAS_INLINE
1866 bool operator == (const const_iterator2 &it) const {
1867 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1868 return it_ == it.it_;
1869 }
1870 BOOST_UBLAS_INLINE
1871 bool operator < (const const_iterator2 &it) const {
1872 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
1873 return it_ < it.it_;
1874 }
1875
1876 private:
1877 const_subiterator2_type it_;
1878 };
1879#endif
1880
1881 BOOST_UBLAS_INLINE
1882 const_iterator2 begin2 () const {
1883 return find2 (0, 0, 0);
1884 }
1885 BOOST_UBLAS_INLINE
1886 const_iterator2 cbegin2 () const {
1887 return begin2 ();
1888 }
1889 BOOST_UBLAS_INLINE
1890 const_iterator2 end2 () const {
1891 return find2 (0, 0, size2 ());
1892 }
1893 BOOST_UBLAS_INLINE
1894 const_iterator2 cend2 () const {
1895 return end2 ();
1896 }
1897
1898 // Reverse iterators
1899
1900 BOOST_UBLAS_INLINE
1901 const_reverse_iterator1 rbegin1 () const {
1902 return const_reverse_iterator1 (end1 ());
1903 }
1904 BOOST_UBLAS_INLINE
1905 const_reverse_iterator1 crbegin1 () const {
1906 return rbegin1 ();
1907 }
1908 BOOST_UBLAS_INLINE
1909 const_reverse_iterator1 rend1 () const {
1910 return const_reverse_iterator1 (begin1 ());
1911 }
1912 BOOST_UBLAS_INLINE
1913 const_reverse_iterator1 crend1 () const {
1914 return rend1 ();
1915 }
1916
1917 BOOST_UBLAS_INLINE
1918 const_reverse_iterator2 rbegin2 () const {
1919 return const_reverse_iterator2 (end2 ());
1920 }
1921 BOOST_UBLAS_INLINE
1922 const_reverse_iterator2 crbegin2 () const {
1923 return rbegin2 ();
1924 }
1925 BOOST_UBLAS_INLINE
1926 const_reverse_iterator2 rend2 () const {
1927 return const_reverse_iterator2 (begin2 ());
1928 }
1929 BOOST_UBLAS_INLINE
1930 const_reverse_iterator2 crend2 () const {
1931 return rend2 ();
1932 }
1933
1934 private:
1935 expression_closure_type e_;
1936 };
1937
1938 template<class E, class F>
1939 struct matrix_unary2_traits {
1940 typedef matrix_unary2<E, F> expression_type;
1941#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
1942 typedef expression_type result_type;
1943#else
1944 typedef typename E::matrix_temporary_type result_type;
1945#endif
1946 };
1947
1948 // (trans m) [i] [j] = m [j] [i]
1949 template<class E>
1950 BOOST_UBLAS_INLINE
1951 typename matrix_unary2_traits<const E, scalar_identity<typename E::value_type> >::result_type
1952 trans (const matrix_expression<E> &e) {
1953 typedef typename matrix_unary2_traits<const E, scalar_identity<typename E::value_type> >::expression_type expression_type;
1954 return expression_type (e ());
1955 }
1956 template<class E>
1957 BOOST_UBLAS_INLINE
1958 typename matrix_unary2_traits<E, scalar_identity<typename E::value_type> >::result_type
1959 trans (matrix_expression<E> &e) {
1960 typedef typename matrix_unary2_traits<E, scalar_identity<typename E::value_type> >::expression_type expression_type;
1961 return expression_type (e ());
1962 }
1963
1964 // (herm m) [i] [j] = conj (m [j] [i])
1965 template<class E>
1966 BOOST_UBLAS_INLINE
1967 typename matrix_unary2_traits<E, scalar_conj<typename E::value_type> >::result_type
1968 herm (const matrix_expression<E> &e) {
1969 typedef typename matrix_unary2_traits<E, scalar_conj<typename E::value_type> >::expression_type expression_type;
1970 return expression_type (e ());
1971 }
1972
1973 template<class E1, class E2, class F>
1974 class matrix_binary:
1975 public matrix_expression<matrix_binary<E1, E2, F> > {
1976
1977 typedef E1 expression1_type;
1978 typedef E2 expression2_type;
1979 typedef F functor_type;
1980 public:
1981 typedef typename E1::const_closure_type expression1_closure_type;
1982 typedef typename E2::const_closure_type expression2_closure_type;
1983 private:
1984 typedef matrix_binary<E1, E2, F> self_type;
1985 public:
1986#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
1987 using matrix_expression<self_type>::operator ();
1988#endif
1989 typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
1990 typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
1991 typedef typename F::result_type value_type;
1992 typedef value_type const_reference;
1993 typedef const_reference reference;
1994 typedef const self_type const_closure_type;
1995 typedef const_closure_type closure_type;
1996 typedef unknown_orientation_tag orientation_category;
1997 typedef unknown_storage_tag storage_category;
1998
1999 // Construction and destruction
2000 BOOST_UBLAS_INLINE
2001 matrix_binary (const E1 &e1, const E2 &e2):
2002 e1_ (e1), e2_ (e2) {}
2003
2004 // Accessors
2005 BOOST_UBLAS_INLINE
2006 size_type size1 () const {
2007 return BOOST_UBLAS_SAME (e1_.size1 (), e2_.size1 ());
2008 }
2009 BOOST_UBLAS_INLINE
2010 size_type size2 () const {
2011 return BOOST_UBLAS_SAME (e1_.size2 (), e2_.size2 ());
2012 }
2013
2014 public:
2015 // Expression accessors
2016 BOOST_UBLAS_INLINE
2017 const expression1_closure_type &expression1 () const {
2018 return e1_;
2019 }
2020 BOOST_UBLAS_INLINE
2021 const expression2_closure_type &expression2 () const {
2022 return e2_;
2023 }
2024
2025 public:
2026 // Element access
2027 BOOST_UBLAS_INLINE
2028 const_reference operator () (size_type i, size_type j) const {
2029 return functor_type::apply (e1_ (i, j), e2_ (i, j));
2030 }
2031
2032 // Closure comparison
2033 BOOST_UBLAS_INLINE
2034 bool same_closure (const matrix_binary &mb) const {
2035 return (*this).expression1 ().same_closure (mb.expression1 ()) &&
2036 (*this).expression2 ().same_closure (mb.expression2 ());
2037 }
2038
2039 // Iterator types
2040 private:
2041 typedef typename E1::const_iterator1 const_iterator11_type;
2042 typedef typename E1::const_iterator2 const_iterator12_type;
2043 typedef typename E2::const_iterator1 const_iterator21_type;
2044 typedef typename E2::const_iterator2 const_iterator22_type;
2045 typedef const value_type *const_pointer;
2046
2047 public:
2048#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
2049 typedef typename iterator_restrict_traits<typename const_iterator11_type::iterator_category,
2050 typename const_iterator21_type::iterator_category>::iterator_category iterator_category1;
2051 typedef indexed_const_iterator1<const_closure_type, iterator_category1> const_iterator1;
2052 typedef const_iterator1 iterator1;
2053 typedef typename iterator_restrict_traits<typename const_iterator12_type::iterator_category,
2054 typename const_iterator22_type::iterator_category>::iterator_category iterator_category2;
2055 typedef indexed_const_iterator2<const_closure_type, iterator_category2> const_iterator2;
2056 typedef const_iterator2 iterator2;
2057#else
2058 class const_iterator1;
2059 typedef const_iterator1 iterator1;
2060 class const_iterator2;
2061 typedef const_iterator2 iterator2;
2062#endif
2063 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
2064 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
2065
2066 // Element lookup
2067 BOOST_UBLAS_INLINE
2068 const_iterator1 find1 (int rank, size_type i, size_type j) const {
2069 const_iterator11_type it11 (e1_.find1 (rank, i, j));
2070 const_iterator11_type it11_end (e1_.find1 (rank, size1 (), j));
2071 const_iterator21_type it21 (e2_.find1 (rank, i, j));
2072 const_iterator21_type it21_end (e2_.find1 (rank, size1 (), j));
2073 BOOST_UBLAS_CHECK (rank == 0 || it11 == it11_end || it11.index2 () == j, internal_logic ())
2074 BOOST_UBLAS_CHECK (rank == 0 || it21 == it21_end || it21.index2 () == j, internal_logic ())
2075 i = (std::min) (it11 != it11_end ? it11.index1 () : size1 (),
2076 it21 != it21_end ? it21.index1 () : size1 ());
2077#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
2078 return const_iterator1 (*this, i, j);
2079#else
2080 return const_iterator1 (*this, i, j, it11, it11_end, it21, it21_end);
2081#endif
2082 }
2083 BOOST_UBLAS_INLINE
2084 const_iterator2 find2 (int rank, size_type i, size_type j) const {
2085 const_iterator12_type it12 (e1_.find2 (rank, i, j));
2086 const_iterator12_type it12_end (e1_.find2 (rank, i, size2 ()));
2087 const_iterator22_type it22 (e2_.find2 (rank, i, j));
2088 const_iterator22_type it22_end (e2_.find2 (rank, i, size2 ()));
2089 BOOST_UBLAS_CHECK (rank == 0 || it12 == it12_end || it12.index1 () == i, internal_logic ())
2090 BOOST_UBLAS_CHECK (rank == 0 || it22 == it22_end || it22.index1 () == i, internal_logic ())
2091 j = (std::min) (it12 != it12_end ? it12.index2 () : size2 (),
2092 it22 != it22_end ? it22.index2 () : size2 ());
2093#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
2094 return const_iterator2 (*this, i, j);
2095#else
2096 return const_iterator2 (*this, i, j, it12, it12_end, it22, it22_end);
2097#endif
2098 }
2099
2100 // Iterators enhance the iterators of the referenced expression
2101 // with the binary functor.
2102
2103#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
2104 class const_iterator1:
2105 public container_const_reference<matrix_binary>,
2106 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
2107 typename E2::const_iterator1::iterator_category>::iterator_category>::template
2108 iterator_base<const_iterator1, value_type>::type {
2109 public:
2110 typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
2111 typename E2::const_iterator1::iterator_category>::iterator_category iterator_category;
2112 typedef typename matrix_binary::difference_type difference_type;
2113 typedef typename matrix_binary::value_type value_type;
2114 typedef typename matrix_binary::const_reference reference;
2115 typedef typename matrix_binary::const_pointer pointer;
2116
2117 typedef const_iterator2 dual_iterator_type;
2118 typedef const_reverse_iterator2 dual_reverse_iterator_type;
2119
2120 // Construction and destruction
2121 BOOST_UBLAS_INLINE
2122 const_iterator1 ():
2123 container_const_reference<self_type> (), i_ (), j_ (), it1_ (), it1_end_ (), it2_ (), it2_end_ () {}
2124 BOOST_UBLAS_INLINE
2125 const_iterator1 (const self_type &mb, size_type i, size_type j,
2126 const const_iterator11_type &it1, const const_iterator11_type &it1_end,
2127 const const_iterator21_type &it2, const const_iterator21_type &it2_end):
2128 container_const_reference<self_type> (mb), i_ (i), j_ (j), it1_ (it1), it1_end_ (it1_end), it2_ (it2), it2_end_ (it2_end) {}
2129
2130 private:
2131 // Dense specializations
2132 BOOST_UBLAS_INLINE
2133 void increment (dense_random_access_iterator_tag) {
2134 ++ i_; ++ it1_; ++ it2_;
2135 }
2136 BOOST_UBLAS_INLINE
2137 void decrement (dense_random_access_iterator_tag) {
2138 -- i_; -- it1_; -- it2_;
2139 }
2140 BOOST_UBLAS_INLINE
2141 void increment (dense_random_access_iterator_tag, difference_type n) {
2142 i_ += n; it1_ += n; it2_ += n;
2143 }
2144 BOOST_UBLAS_INLINE
2145 void decrement (dense_random_access_iterator_tag, difference_type n) {
2146 i_ -= n; it1_ -= n; it2_ -= n;
2147 }
2148 BOOST_UBLAS_INLINE
2149 value_type dereference (dense_random_access_iterator_tag) const {
2150 return functor_type::apply (*it1_, *it2_);
2151 }
2152
2153 // Packed specializations
2154 BOOST_UBLAS_INLINE
2155 void increment (packed_random_access_iterator_tag) {
2156 if (it1_ != it1_end_)
2157 if (it1_.index1 () <= i_)
2158 ++ it1_;
2159 if (it2_ != it2_end_)
2160 if (it2_.index1 () <= i_)
2161 ++ it2_;
2162 ++ i_;
2163 }
2164 BOOST_UBLAS_INLINE
2165 void decrement (packed_random_access_iterator_tag) {
2166 if (it1_ != it1_end_)
2167 if (i_ <= it1_.index1 ())
2168 -- it1_;
2169 if (it2_ != it2_end_)
2170 if (i_ <= it2_.index1 ())
2171 -- it2_;
2172 -- i_;
2173 }
2174 BOOST_UBLAS_INLINE
2175 void increment (packed_random_access_iterator_tag, difference_type n) {
2176 while (n > 0) {
2177 increment (packed_random_access_iterator_tag ());
2178 --n;
2179 }
2180 while (n < 0) {
2181 decrement (packed_random_access_iterator_tag ());
2182 ++n;
2183 }
2184 }
2185 BOOST_UBLAS_INLINE
2186 void decrement (packed_random_access_iterator_tag, difference_type n) {
2187 while (n > 0) {
2188 decrement (packed_random_access_iterator_tag ());
2189 --n;
2190 }
2191 while (n < 0) {
2192 increment (packed_random_access_iterator_tag ());
2193 ++n;
2194 }
2195 }
2196 BOOST_UBLAS_INLINE
2197 value_type dereference (packed_random_access_iterator_tag) const {
2198 value_type t1 = value_type/*zero*/();
2199 if (it1_ != it1_end_) {
2200 BOOST_UBLAS_CHECK (it1_.index2 () == j_, internal_logic ());
2201 if (it1_.index1 () == i_)
2202 t1 = *it1_;
2203 }
2204 value_type t2 = value_type/*zero*/();
2205 if (it2_ != it2_end_) {
2206 BOOST_UBLAS_CHECK (it2_.index2 () == j_, internal_logic ());
2207 if (it2_.index1 () == i_)
2208 t2 = *it2_;
2209 }
2210 return functor_type::apply (t1, t2);
2211 }
2212
2213 // Sparse specializations
2214 BOOST_UBLAS_INLINE
2215 void increment (sparse_bidirectional_iterator_tag) {
2216 size_type index1 = (*this) ().size1 ();
2217 if (it1_ != it1_end_) {
2218 if (it1_.index1 () <= i_)
2219 ++ it1_;
2220 if (it1_ != it1_end_)
2221 index1 = it1_.index1 ();
2222 }
2223 size_type index2 = (*this) ().size1 ();
2224 if (it2_ != it2_end_)
2225 if (it2_.index1 () <= i_)
2226 ++ it2_;
2227 if (it2_ != it2_end_) {
2228 index2 = it2_.index1 ();
2229 }
2230 i_ = (std::min) (index1, index2);
2231 }
2232 BOOST_UBLAS_INLINE
2233 void decrement (sparse_bidirectional_iterator_tag) {
2234 size_type index1 = (*this) ().size1 ();
2235 if (it1_ != it1_end_) {
2236 if (i_ <= it1_.index1 ())
2237 -- it1_;
2238 if (it1_ != it1_end_)
2239 index1 = it1_.index1 ();
2240 }
2241 size_type index2 = (*this) ().size1 ();
2242 if (it2_ != it2_end_) {
2243 if (i_ <= it2_.index1 ())
2244 -- it2_;
2245 if (it2_ != it2_end_)
2246 index2 = it2_.index1 ();
2247 }
2248 i_ = (std::max) (index1, index2);
2249 }
2250 BOOST_UBLAS_INLINE
2251 void increment (sparse_bidirectional_iterator_tag, difference_type n) {
2252 while (n > 0) {
2253 increment (sparse_bidirectional_iterator_tag ());
2254 --n;
2255 }
2256 while (n < 0) {
2257 decrement (sparse_bidirectional_iterator_tag ());
2258 ++n;
2259 }
2260 }
2261 BOOST_UBLAS_INLINE
2262 void decrement (sparse_bidirectional_iterator_tag, difference_type n) {
2263 while (n > 0) {
2264 decrement (sparse_bidirectional_iterator_tag ());
2265 --n;
2266 }
2267 while (n < 0) {
2268 increment (sparse_bidirectional_iterator_tag ());
2269 ++n;
2270 }
2271 }
2272 BOOST_UBLAS_INLINE
2273 value_type dereference (sparse_bidirectional_iterator_tag) const {
2274 value_type t1 = value_type/*zero*/();
2275 if (it1_ != it1_end_) {
2276 BOOST_UBLAS_CHECK (it1_.index2 () == j_, internal_logic ());
2277 if (it1_.index1 () == i_)
2278 t1 = *it1_;
2279 }
2280 value_type t2 = value_type/*zero*/();
2281 if (it2_ != it2_end_) {
2282 BOOST_UBLAS_CHECK (it2_.index2 () == j_, internal_logic ());
2283 if (it2_.index1 () == i_)
2284 t2 = *it2_;
2285 }
2286 return functor_type::apply (t1, t2);
2287 }
2288
2289 public:
2290 // Arithmetic
2291 BOOST_UBLAS_INLINE
2292 const_iterator1 &operator ++ () {
2293 increment (iterator_category ());
2294 return *this;
2295 }
2296 BOOST_UBLAS_INLINE
2297 const_iterator1 &operator -- () {
2298 decrement (iterator_category ());
2299 return *this;
2300 }
2301 BOOST_UBLAS_INLINE
2302 const_iterator1 &operator += (difference_type n) {
2303 increment (iterator_category (), n);
2304 return *this;
2305 }
2306 BOOST_UBLAS_INLINE
2307 const_iterator1 &operator -= (difference_type n) {
2308 decrement (iterator_category (), n);
2309 return *this;
2310 }
2311 BOOST_UBLAS_INLINE
2312 difference_type operator - (const const_iterator1 &it) const {
2313 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
2314 BOOST_UBLAS_CHECK (index2 () == it.index2 (), external_logic ());
2315 return index1 () - it.index1 ();
2316 }
2317
2318 // Dereference
2319 BOOST_UBLAS_INLINE
2320 const_reference operator * () const {
2321 return dereference (iterator_category ());
2322 }
2323 BOOST_UBLAS_INLINE
2324 const_reference operator [] (difference_type n) const {
2325 return *(*this + n);
2326 }
2327
2328#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
2329 BOOST_UBLAS_INLINE
2330#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2331 typename self_type::
2332#endif
2333 const_iterator2 begin () const {
2334 return (*this) ().find2 (1, index1 (), 0);
2335 }
2336 BOOST_UBLAS_INLINE
2337#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2338 typename self_type::
2339#endif
2340 const_iterator2 cbegin () const {
2341 return begin ();
2342 }
2343 BOOST_UBLAS_INLINE
2344#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2345 typename self_type::
2346#endif
2347 const_iterator2 end () const {
2348 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
2349 }
2350 BOOST_UBLAS_INLINE
2351#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2352 typename self_type::
2353#endif
2354 const_iterator2 cend () const {
2355 return end ();
2356 }
2357 BOOST_UBLAS_INLINE
2358#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2359 typename self_type::
2360#endif
2361 const_reverse_iterator2 rbegin () const {
2362 return const_reverse_iterator2 (end ());
2363 }
2364 BOOST_UBLAS_INLINE
2365#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2366 typename self_type::
2367#endif
2368 const_reverse_iterator2 crbegin () const {
2369 return rbegin ();
2370 }
2371 BOOST_UBLAS_INLINE
2372#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2373 typename self_type::
2374#endif
2375 const_reverse_iterator2 rend () const {
2376 return const_reverse_iterator2 (begin ());
2377 }
2378 BOOST_UBLAS_INLINE
2379#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2380 typename self_type::
2381#endif
2382 const_reverse_iterator2 crend () const {
2383 return rend ();
2384 }
2385#endif
2386
2387 // Indices
2388 BOOST_UBLAS_INLINE
2389 size_type index1 () const {
2390 return i_;
2391 }
2392 BOOST_UBLAS_INLINE
2393 size_type index2 () const {
2394 // if (it1_ != it1_end_ && it2_ != it2_end_)
2395 // return BOOST_UBLAS_SAME (it1_.index2 (), it2_.index2 ());
2396 // else
2397 return j_;
2398 }
2399
2400 // Assignment
2401 BOOST_UBLAS_INLINE
2402 const_iterator1 &operator = (const const_iterator1 &it) {
2403 container_const_reference<self_type>::assign (&it ());
2404 i_ = it.i_;
2405 j_ = it.j_;
2406 it1_ = it.it1_;
2407 it1_end_ = it.it1_end_;
2408 it2_ = it.it2_;
2409 it2_end_ = it.it2_end_;
2410 return *this;
2411 }
2412
2413 // Comparison
2414 BOOST_UBLAS_INLINE
2415 bool operator == (const const_iterator1 &it) const {
2416 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
2417 BOOST_UBLAS_CHECK (index2 () == it.index2 (), external_logic ());
2418 return index1 () == it.index1 ();
2419 }
2420 BOOST_UBLAS_INLINE
2421 bool operator < (const const_iterator1 &it) const {
2422 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
2423 BOOST_UBLAS_CHECK (index2 () == it.index2 (), external_logic ());
2424 return index1 () < it.index1 ();
2425 }
2426
2427 private:
2428 size_type i_;
2429 size_type j_;
2430 const_iterator11_type it1_;
2431 const_iterator11_type it1_end_;
2432 const_iterator21_type it2_;
2433 const_iterator21_type it2_end_;
2434 };
2435#endif
2436
2437 BOOST_UBLAS_INLINE
2438 const_iterator1 begin1 () const {
2439 return find1 (0, 0, 0);
2440 }
2441 BOOST_UBLAS_INLINE
2442 const_iterator1 cbegin1 () const {
2443 return begin1 ();
2444 }
2445 BOOST_UBLAS_INLINE
2446 const_iterator1 end1 () const {
2447 return find1 (0, size1 (), 0);
2448 }
2449 BOOST_UBLAS_INLINE
2450 const_iterator1 cend1 () const {
2451 return end1 ();
2452 }
2453
2454#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
2455 class const_iterator2:
2456 public container_const_reference<matrix_binary>,
2457 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator2::iterator_category,
2458 typename E2::const_iterator2::iterator_category>::iterator_category>::template
2459 iterator_base<const_iterator2, value_type>::type {
2460 public:
2461 typedef typename iterator_restrict_traits<typename E1::const_iterator2::iterator_category,
2462 typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
2463 typedef typename matrix_binary::difference_type difference_type;
2464 typedef typename matrix_binary::value_type value_type;
2465 typedef typename matrix_binary::const_reference reference;
2466 typedef typename matrix_binary::const_pointer pointer;
2467
2468 typedef const_iterator1 dual_iterator_type;
2469 typedef const_reverse_iterator1 dual_reverse_iterator_type;
2470
2471 // Construction and destruction
2472 BOOST_UBLAS_INLINE
2473 const_iterator2 ():
2474 container_const_reference<self_type> (), i_ (), j_ (), it1_ (), it1_end_ (), it2_ (), it2_end_ () {}
2475 BOOST_UBLAS_INLINE
2476 const_iterator2 (const self_type &mb, size_type i, size_type j,
2477 const const_iterator12_type &it1, const const_iterator12_type &it1_end,
2478 const const_iterator22_type &it2, const const_iterator22_type &it2_end):
2479 container_const_reference<self_type> (mb), i_ (i), j_ (j), it1_ (it1), it1_end_ (it1_end), it2_ (it2), it2_end_ (it2_end) {}
2480
2481 private:
2482 // Dense access specializations
2483 BOOST_UBLAS_INLINE
2484 void increment (dense_random_access_iterator_tag) {
2485 ++ j_; ++ it1_; ++ it2_;
2486 }
2487 BOOST_UBLAS_INLINE
2488 void decrement (dense_random_access_iterator_tag) {
2489 -- j_; -- it1_; -- it2_;
2490 }
2491 BOOST_UBLAS_INLINE
2492 void increment (dense_random_access_iterator_tag, difference_type n) {
2493 j_ += n; it1_ += n; it2_ += n;
2494 }
2495 BOOST_UBLAS_INLINE
2496 void decrement (dense_random_access_iterator_tag, difference_type n) {
2497 j_ -= n; it1_ -= n; it2_ -= n;
2498 }
2499 BOOST_UBLAS_INLINE
2500 value_type dereference (dense_random_access_iterator_tag) const {
2501 return functor_type::apply (*it1_, *it2_);
2502 }
2503
2504 // Packed specializations
2505 BOOST_UBLAS_INLINE
2506 void increment (packed_random_access_iterator_tag) {
2507 if (it1_ != it1_end_)
2508 if (it1_.index2 () <= j_)
2509 ++ it1_;
2510 if (it2_ != it2_end_)
2511 if (it2_.index2 () <= j_)
2512 ++ it2_;
2513 ++ j_;
2514 }
2515 BOOST_UBLAS_INLINE
2516 void decrement (packed_random_access_iterator_tag) {
2517 if (it1_ != it1_end_)
2518 if (j_ <= it1_.index2 ())
2519 -- it1_;
2520 if (it2_ != it2_end_)
2521 if (j_ <= it2_.index2 ())
2522 -- it2_;
2523 -- j_;
2524 }
2525 BOOST_UBLAS_INLINE
2526 void increment (packed_random_access_iterator_tag, difference_type n) {
2527 while (n > 0) {
2528 increment (packed_random_access_iterator_tag ());
2529 --n;
2530 }
2531 while (n < 0) {
2532 decrement (packed_random_access_iterator_tag ());
2533 ++n;
2534 }
2535 }
2536 BOOST_UBLAS_INLINE
2537 void decrement (packed_random_access_iterator_tag, difference_type n) {
2538 while (n > 0) {
2539 decrement (packed_random_access_iterator_tag ());
2540 --n;
2541 }
2542 while (n < 0) {
2543 increment (packed_random_access_iterator_tag ());
2544 ++n;
2545 }
2546 }
2547 BOOST_UBLAS_INLINE
2548 value_type dereference (packed_random_access_iterator_tag) const {
2549 value_type t1 = value_type/*zero*/();
2550 if (it1_ != it1_end_) {
2551 BOOST_UBLAS_CHECK (it1_.index1 () == i_, internal_logic ());
2552 if (it1_.index2 () == j_)
2553 t1 = *it1_;
2554 }
2555 value_type t2 = value_type/*zero*/();
2556 if (it2_ != it2_end_) {
2557 BOOST_UBLAS_CHECK (it2_.index1 () == i_, internal_logic ());
2558 if (it2_.index2 () == j_)
2559 t2 = *it2_;
2560 }
2561 return functor_type::apply (t1, t2);
2562 }
2563
2564 // Sparse specializations
2565 BOOST_UBLAS_INLINE
2566 void increment (sparse_bidirectional_iterator_tag) {
2567 size_type index1 = (*this) ().size2 ();
2568 if (it1_ != it1_end_) {
2569 if (it1_.index2 () <= j_)
2570 ++ it1_;
2571 if (it1_ != it1_end_)
2572 index1 = it1_.index2 ();
2573 }
2574 size_type index2 = (*this) ().size2 ();
2575 if (it2_ != it2_end_) {
2576 if (it2_.index2 () <= j_)
2577 ++ it2_;
2578 if (it2_ != it2_end_)
2579 index2 = it2_.index2 ();
2580 }
2581 j_ = (std::min) (index1, index2);
2582 }
2583 BOOST_UBLAS_INLINE
2584 void decrement (sparse_bidirectional_iterator_tag) {
2585 size_type index1 = (*this) ().size2 ();
2586 if (it1_ != it1_end_) {
2587 if (j_ <= it1_.index2 ())
2588 -- it1_;
2589 if (it1_ != it1_end_)
2590 index1 = it1_.index2 ();
2591 }
2592 size_type index2 = (*this) ().size2 ();
2593 if (it2_ != it2_end_) {
2594 if (j_ <= it2_.index2 ())
2595 -- it2_;
2596 if (it2_ != it2_end_)
2597 index2 = it2_.index2 ();
2598 }
2599 j_ = (std::max) (index1, index2);
2600 }
2601 BOOST_UBLAS_INLINE
2602 void increment (sparse_bidirectional_iterator_tag, difference_type n) {
2603 while (n > 0) {
2604 increment (sparse_bidirectional_iterator_tag ());
2605 --n;
2606 }
2607 while (n < 0) {
2608 decrement (sparse_bidirectional_iterator_tag ());
2609 ++n;
2610 }
2611 }
2612 BOOST_UBLAS_INLINE
2613 void decrement (sparse_bidirectional_iterator_tag, difference_type n) {
2614 while (n > 0) {
2615 decrement (sparse_bidirectional_iterator_tag ());
2616 --n;
2617 }
2618 while (n < 0) {
2619 increment (sparse_bidirectional_iterator_tag ());
2620 ++n;
2621 }
2622 }
2623 BOOST_UBLAS_INLINE
2624 value_type dereference (sparse_bidirectional_iterator_tag) const {
2625 value_type t1 = value_type/*zero*/();
2626 if (it1_ != it1_end_) {
2627 BOOST_UBLAS_CHECK (it1_.index1 () == i_, internal_logic ());
2628 if (it1_.index2 () == j_)
2629 t1 = *it1_;
2630 }
2631 value_type t2 = value_type/*zero*/();
2632 if (it2_ != it2_end_) {
2633 BOOST_UBLAS_CHECK (it2_.index1 () == i_, internal_logic ());
2634 if (it2_.index2 () == j_)
2635 t2 = *it2_;
2636 }
2637 return functor_type::apply (t1, t2);
2638 }
2639
2640 public:
2641 // Arithmetic
2642 BOOST_UBLAS_INLINE
2643 const_iterator2 &operator ++ () {
2644 increment (iterator_category ());
2645 return *this;
2646 }
2647 BOOST_UBLAS_INLINE
2648 const_iterator2 &operator -- () {
2649 decrement (iterator_category ());
2650 return *this;
2651 }
2652 BOOST_UBLAS_INLINE
2653 const_iterator2 &operator += (difference_type n) {
2654 increment (iterator_category (), n);
2655 return *this;
2656 }
2657 BOOST_UBLAS_INLINE
2658 const_iterator2 &operator -= (difference_type n) {
2659 decrement (iterator_category (), n);
2660 return *this;
2661 }
2662 BOOST_UBLAS_INLINE
2663 difference_type operator - (const const_iterator2 &it) const {
2664 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
2665 BOOST_UBLAS_CHECK (index1 () == it.index1 (), external_logic ());
2666 return index2 () - it.index2 ();
2667 }
2668
2669 // Dereference
2670 BOOST_UBLAS_INLINE
2671 const_reference operator * () const {
2672 return dereference (iterator_category ());
2673 }
2674 BOOST_UBLAS_INLINE
2675 const_reference operator [] (difference_type n) const {
2676 return *(*this + n);
2677 }
2678
2679#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
2680 BOOST_UBLAS_INLINE
2681#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2682 typename self_type::
2683#endif
2684 const_iterator1 begin () const {
2685 return (*this) ().find1 (1, 0, index2 ());
2686 }
2687 BOOST_UBLAS_INLINE
2688#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2689 typename self_type::
2690#endif
2691 const_iterator1 cbegin () const {
2692 return begin ();
2693 }
2694 BOOST_UBLAS_INLINE
2695#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2696 typename self_type::
2697#endif
2698 const_iterator1 end () const {
2699 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
2700 }
2701 BOOST_UBLAS_INLINE
2702#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2703 typename self_type::
2704#endif
2705 const_iterator1 cend () const {
2706 return end ();
2707 }
2708 BOOST_UBLAS_INLINE
2709#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2710 typename self_type::
2711#endif
2712 const_reverse_iterator1 rbegin () const {
2713 return const_reverse_iterator1 (end ());
2714 }
2715 BOOST_UBLAS_INLINE
2716#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2717 typename self_type::
2718#endif
2719 const_reverse_iterator1 crbegin () const {
2720 return rbegin ();
2721 }
2722 BOOST_UBLAS_INLINE
2723#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2724 typename self_type::
2725#endif
2726 const_reverse_iterator1 rend () const {
2727 return const_reverse_iterator1 (begin ());
2728 }
2729 BOOST_UBLAS_INLINE
2730#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
2731 typename self_type::
2732#endif
2733 const_reverse_iterator1 crend () const {
2734 return rend ();
2735 }
2736#endif
2737
2738 // Indices
2739 BOOST_UBLAS_INLINE
2740 size_type index1 () const {
2741 // if (it1_ != it1_end_ && it2_ != it2_end_)
2742 // return BOOST_UBLAS_SAME (it1_.index1 (), it2_.index1 ());
2743 // else
2744 return i_;
2745 }
2746 BOOST_UBLAS_INLINE
2747 size_type index2 () const {
2748 return j_;
2749 }
2750
2751 // Assignment
2752 BOOST_UBLAS_INLINE
2753 const_iterator2 &operator = (const const_iterator2 &it) {
2754 container_const_reference<self_type>::assign (&it ());
2755 i_ = it.i_;
2756 j_ = it.j_;
2757 it1_ = it.it1_;
2758 it1_end_ = it.it1_end_;
2759 it2_ = it.it2_;
2760 it2_end_ = it.it2_end_;
2761 return *this;
2762 }
2763
2764 // Comparison
2765 BOOST_UBLAS_INLINE
2766 bool operator == (const const_iterator2 &it) const {
2767 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
2768 BOOST_UBLAS_CHECK (index1 () == it.index1 (), external_logic ());
2769 return index2 () == it.index2 ();
2770 }
2771 BOOST_UBLAS_INLINE
2772 bool operator < (const const_iterator2 &it) const {
2773 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
2774 BOOST_UBLAS_CHECK (index1 () == it.index1 (), external_logic ());
2775 return index2 () < it.index2 ();
2776 }
2777
2778 private:
2779 size_type i_;
2780 size_type j_;
2781 const_iterator12_type it1_;
2782 const_iterator12_type it1_end_;
2783 const_iterator22_type it2_;
2784 const_iterator22_type it2_end_;
2785 };
2786#endif
2787
2788 BOOST_UBLAS_INLINE
2789 const_iterator2 begin2 () const {
2790 return find2 (0, 0, 0);
2791 }
2792 BOOST_UBLAS_INLINE
2793 const_iterator2 cbegin2 () const {
2794 return begin2 ();
2795 }
2796 BOOST_UBLAS_INLINE
2797 const_iterator2 end2 () const {
2798 return find2 (0, 0, size2 ());
2799 }
2800 BOOST_UBLAS_INLINE
2801 const_iterator2 cend2 () const {
2802 return end2 ();
2803 }
2804
2805 // Reverse iterators
2806
2807 BOOST_UBLAS_INLINE
2808 const_reverse_iterator1 rbegin1 () const {
2809 return const_reverse_iterator1 (end1 ());
2810 }
2811 BOOST_UBLAS_INLINE
2812 const_reverse_iterator1 crbegin1 () const {
2813 return rbegin1 ();
2814 }
2815 BOOST_UBLAS_INLINE
2816 const_reverse_iterator1 rend1 () const {
2817 return const_reverse_iterator1 (begin1 ());
2818 }
2819 BOOST_UBLAS_INLINE
2820 const_reverse_iterator1 crend1 () const {
2821 return rend1 ();
2822 }
2823
2824 BOOST_UBLAS_INLINE
2825 const_reverse_iterator2 rbegin2 () const {
2826 return const_reverse_iterator2 (end2 ());
2827 }
2828 BOOST_UBLAS_INLINE
2829 const_reverse_iterator2 crbegin2 () const {
2830 return rbegin2 ();
2831 }
2832 BOOST_UBLAS_INLINE
2833 const_reverse_iterator2 rend2 () const {
2834 return const_reverse_iterator2 (begin2 ());
2835 }
2836 BOOST_UBLAS_INLINE
2837 const_reverse_iterator2 crend2 () const {
2838 return rend2 ();
2839 }
2840
2841 private:
2842 expression1_closure_type e1_;
2843 expression2_closure_type e2_;
2844 };
2845
2846 template<class E1, class E2, class F>
2847 struct matrix_binary_traits {
2848 typedef matrix_binary<E1, E2, F> expression_type;
2849#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
2850 typedef expression_type result_type;
2851#else
2852 typedef typename E1::matrix_temporary_type result_type;
2853#endif
2854 };
2855
2856 // (m1 + m2) [i] [j] = m1 [i] [j] + m2 [i] [j]
2857 template<class E1, class E2>
2858 BOOST_UBLAS_INLINE
2859 typename matrix_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
2860 typename E2::value_type> >::result_type
2861 operator + (const matrix_expression<E1> &e1,
2862 const matrix_expression<E2> &e2) {
2863 typedef typename matrix_binary_traits<E1, E2, scalar_plus<typename E1::value_type,
2864 typename E2::value_type> >::expression_type expression_type;
2865 return expression_type (e1 (), e2 ());
2866 }
2867
2868 // (m1 - m2) [i] [j] = m1 [i] [j] - m2 [i] [j]
2869 template<class E1, class E2>
2870 BOOST_UBLAS_INLINE
2871 typename matrix_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
2872 typename E2::value_type> >::result_type
2873 operator - (const matrix_expression<E1> &e1,
2874 const matrix_expression<E2> &e2) {
2875 typedef typename matrix_binary_traits<E1, E2, scalar_minus<typename E1::value_type,
2876 typename E2::value_type> >::expression_type expression_type;
2877 return expression_type (e1 (), e2 ());
2878 }
2879
2880 // (m1 * m2) [i] [j] = m1 [i] [j] * m2 [i] [j]
2881 template<class E1, class E2>
2882 BOOST_UBLAS_INLINE
2883 typename matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
2884 typename E2::value_type> >::result_type
2885 element_prod (const matrix_expression<E1> &e1,
2886 const matrix_expression<E2> &e2) {
2887 typedef typename matrix_binary_traits<E1, E2, scalar_multiplies<typename E1::value_type,
2888 typename E2::value_type> >::expression_type expression_type;
2889 return expression_type (e1 (), e2 ());
2890 }
2891
2892 // (m1 / m2) [i] [j] = m1 [i] [j] / m2 [i] [j]
2893 template<class E1, class E2>
2894 BOOST_UBLAS_INLINE
2895 typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
2896 typename E2::value_type> >::result_type
2897 element_div (const matrix_expression<E1> &e1,
2898 const matrix_expression<E2> &e2) {
2899 typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
2900 typename E2::value_type> >::expression_type expression_type;
2901 return expression_type (e1 (), e2 ());
2902 }
2903
2904 template<class E1, class E2, class F>
2905 class matrix_binary_scalar1:
2906 public matrix_expression<matrix_binary_scalar1<E1, E2, F> > {
2907
2908 typedef E1 expression1_type;
2909 typedef E2 expression2_type;
2910 typedef F functor_type;
2911 typedef const E1& expression1_closure_type;
2912 typedef typename E2::const_closure_type expression2_closure_type;
2913 typedef matrix_binary_scalar1<E1, E2, F> self_type;
2914 public:
2915#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
2916 using matrix_expression<self_type>::operator ();
2917#endif
2918 typedef typename E2::size_type size_type;
2919 typedef typename E2::difference_type difference_type;
2920 typedef typename F::result_type value_type;
2921 typedef value_type const_reference;
2922 typedef const_reference reference;
2923 typedef const self_type const_closure_type;
2924 typedef const_closure_type closure_type;
2925 typedef typename E2::orientation_category orientation_category;
2926 typedef unknown_storage_tag storage_category;
2927
2928 // Construction and destruction
2929 BOOST_UBLAS_INLINE
2930 matrix_binary_scalar1 (const expression1_type &e1, const expression2_type &e2):
2931 e1_ (e1), e2_ (e2) {}
2932
2933 // Accessors
2934 BOOST_UBLAS_INLINE
2935 size_type size1 () const {
2936 return e2_.size1 ();
2937 }
2938 BOOST_UBLAS_INLINE
2939 size_type size2 () const {
2940 return e2_.size2 ();
2941 }
2942
2943 public:
2944 // Element access
2945 BOOST_UBLAS_INLINE
2946 const_reference operator () (size_type i, size_type j) const {
2947 return functor_type::apply (expression1_type (e1_), e2_ (i, j));
2948 }
2949
2950 // Closure comparison
2951 BOOST_UBLAS_INLINE
2952 bool same_closure (const matrix_binary_scalar1 &mbs1) const {
2953 return &e1_ == &(mbs1.e1_) &&
2954 (*this).e2_.same_closure (mbs1.e2_);
2955 }
2956
2957 // Iterator types
2958 private:
2959 typedef expression1_type const_subiterator1_type;
2960 typedef typename E2::const_iterator1 const_iterator21_type;
2961 typedef typename E2::const_iterator2 const_iterator22_type;
2962 typedef const value_type *const_pointer;
2963
2964 public:
2965#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
2966 typedef indexed_const_iterator1<const_closure_type, typename const_iterator21_type::iterator_category> const_iterator1;
2967 typedef const_iterator1 iterator1;
2968 typedef indexed_const_iterator2<const_closure_type, typename const_iterator22_type::iterator_category> const_iterator2;
2969 typedef const_iterator2 iterator2;
2970#else
2971 class const_iterator1;
2972 typedef const_iterator1 iterator1;
2973 class const_iterator2;
2974 typedef const_iterator2 iterator2;
2975#endif
2976 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
2977 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
2978
2979 // Element lookup
2980 BOOST_UBLAS_INLINE
2981 const_iterator1 find1 (int rank, size_type i, size_type j) const {
2982 const_iterator21_type it21 (e2_.find1 (rank, i, j));
2983#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
2984 return const_iterator1 (*this, it21.index1 (), it21.index2 ());
2985#else
2986 return const_iterator1 (*this, const_subiterator1_type (e1_), it21);
2987#endif
2988 }
2989 BOOST_UBLAS_INLINE
2990 const_iterator2 find2 (int rank, size_type i, size_type j) const {
2991 const_iterator22_type it22 (e2_.find2 (rank, i, j));
2992#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
2993 return const_iterator2 (*this, it22.index1 (), it22.index2 ());
2994#else
2995 return const_iterator2 (*this, const_subiterator1_type (e1_), it22);
2996#endif
2997 }
2998
2999 // Iterators enhance the iterators of the referenced expression
3000 // with the binary functor.
3001
3002#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
3003 class const_iterator1:
3004 public container_const_reference<matrix_binary_scalar1>,
3005 public iterator_base_traits<typename E2::const_iterator1::iterator_category>::template
3006 iterator_base<const_iterator1, value_type>::type {
3007 public:
3008 typedef typename E2::const_iterator1::iterator_category iterator_category;
3009 typedef typename matrix_binary_scalar1::difference_type difference_type;
3010 typedef typename matrix_binary_scalar1::value_type value_type;
3011 typedef typename matrix_binary_scalar1::const_reference reference;
3012 typedef typename matrix_binary_scalar1::const_pointer pointer;
3013
3014 typedef const_iterator2 dual_iterator_type;
3015 typedef const_reverse_iterator2 dual_reverse_iterator_type;
3016
3017 // Construction and destruction
3018 BOOST_UBLAS_INLINE
3019 const_iterator1 ():
3020 container_const_reference<self_type> (), it1_ (), it2_ () {}
3021 BOOST_UBLAS_INLINE
3022 const_iterator1 (const self_type &mbs, const const_subiterator1_type &it1, const const_iterator21_type &it2):
3023 container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}
3024
3025 // Arithmetic
3026 BOOST_UBLAS_INLINE
3027 const_iterator1 &operator ++ () {
3028 ++ it2_;
3029 return *this;
3030 }
3031 BOOST_UBLAS_INLINE
3032 const_iterator1 &operator -- () {
3033 -- it2_ ;
3034 return *this;
3035 }
3036 BOOST_UBLAS_INLINE
3037 const_iterator1 &operator += (difference_type n) {
3038 it2_ += n;
3039 return *this;
3040 }
3041 BOOST_UBLAS_INLINE
3042 const_iterator1 &operator -= (difference_type n) {
3043 it2_ -= n;
3044 return *this;
3045 }
3046 BOOST_UBLAS_INLINE
3047 difference_type operator - (const const_iterator1 &it) const {
3048 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3049 // FIXME we shouldn't compare floats
3050 // BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
3051 return it2_ - it.it2_;
3052 }
3053
3054 // Dereference
3055 BOOST_UBLAS_INLINE
3056 const_reference operator * () const {
3057 return functor_type::apply (it1_, *it2_);
3058 }
3059 BOOST_UBLAS_INLINE
3060 const_reference operator [] (difference_type n) const {
3061 return *(*this + n);
3062 }
3063
3064#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
3065 BOOST_UBLAS_INLINE
3066#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3067 typename self_type::
3068#endif
3069 const_iterator2 begin () const {
3070 return (*this) ().find2 (1, index1 (), 0);
3071 }
3072 BOOST_UBLAS_INLINE
3073#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3074 typename self_type::
3075#endif
3076 const_iterator2 cbegin () const {
3077 return begin ();
3078 }
3079 BOOST_UBLAS_INLINE
3080#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3081 typename self_type::
3082#endif
3083 const_iterator2 end () const {
3084 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
3085 }
3086 BOOST_UBLAS_INLINE
3087#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3088 typename self_type::
3089#endif
3090 const_iterator2 cend () const {
3091 return end ();
3092 }
3093 BOOST_UBLAS_INLINE
3094#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3095 typename self_type::
3096#endif
3097 const_reverse_iterator2 rbegin () const {
3098 return const_reverse_iterator2 (end ());
3099 }
3100 BOOST_UBLAS_INLINE
3101#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3102 typename self_type::
3103#endif
3104 const_reverse_iterator2 crbegin () const {
3105 return rbegin ();
3106 }
3107 BOOST_UBLAS_INLINE
3108#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3109 typename self_type::
3110#endif
3111 const_reverse_iterator2 rend () const {
3112 return const_reverse_iterator2 (begin ());
3113 }
3114 BOOST_UBLAS_INLINE
3115#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3116 typename self_type::
3117#endif
3118 const_reverse_iterator2 crend () const {
3119 return rend ();
3120 }
3121#endif
3122
3123 // Indices
3124 BOOST_UBLAS_INLINE
3125 size_type index1 () const {
3126 return it2_.index1 ();
3127 }
3128 BOOST_UBLAS_INLINE
3129 size_type index2 () const {
3130 return it2_.index2 ();
3131 }
3132
3133 // Assignment
3134 BOOST_UBLAS_INLINE
3135 const_iterator1 &operator = (const const_iterator1 &it) {
3136 container_const_reference<self_type>::assign (&it ());
3137 it1_ = it.it1_;
3138 it2_ = it.it2_;
3139 return *this;
3140 }
3141
3142 // Comparison
3143 BOOST_UBLAS_INLINE
3144 bool operator == (const const_iterator1 &it) const {
3145 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3146 // FIXME we shouldn't compare floats
3147 // BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
3148 return it2_ == it.it2_;
3149 }
3150 BOOST_UBLAS_INLINE
3151 bool operator < (const const_iterator1 &it) const {
3152 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3153 // FIXME we shouldn't compare floats
3154 // BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
3155 return it2_ < it.it2_;
3156 }
3157
3158 private:
3159 const_subiterator1_type it1_;
3160 const_iterator21_type it2_;
3161 };
3162#endif
3163
3164 BOOST_UBLAS_INLINE
3165 const_iterator1 begin1 () const {
3166 return find1 (0, 0, 0);
3167 }
3168 BOOST_UBLAS_INLINE
3169 const_iterator1 cbegin1 () const {
3170 return begin1 ();
3171 }
3172 BOOST_UBLAS_INLINE
3173 const_iterator1 end1 () const {
3174 return find1 (0, size1 (), 0);
3175 }
3176 BOOST_UBLAS_INLINE
3177 const_iterator1 cend1 () const {
3178 return end1 ();
3179 }
3180
3181#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
3182 class const_iterator2:
3183 public container_const_reference<matrix_binary_scalar1>,
3184 public iterator_base_traits<typename E2::const_iterator2::iterator_category>::template
3185 iterator_base<const_iterator2, value_type>::type {
3186 public:
3187 typedef typename E2::const_iterator2::iterator_category iterator_category;
3188 typedef typename matrix_binary_scalar1::difference_type difference_type;
3189 typedef typename matrix_binary_scalar1::value_type value_type;
3190 typedef typename matrix_binary_scalar1::const_reference reference;
3191 typedef typename matrix_binary_scalar1::const_pointer pointer;
3192
3193 typedef const_iterator1 dual_iterator_type;
3194 typedef const_reverse_iterator1 dual_reverse_iterator_type;
3195
3196 // Construction and destruction
3197 BOOST_UBLAS_INLINE
3198 const_iterator2 ():
3199 container_const_reference<self_type> (), it1_ (), it2_ () {}
3200 BOOST_UBLAS_INLINE
3201 const_iterator2 (const self_type &mbs, const const_subiterator1_type &it1, const const_iterator22_type &it2):
3202 container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}
3203
3204 // Arithmetic
3205 BOOST_UBLAS_INLINE
3206 const_iterator2 &operator ++ () {
3207 ++ it2_;
3208 return *this;
3209 }
3210 BOOST_UBLAS_INLINE
3211 const_iterator2 &operator -- () {
3212 -- it2_;
3213 return *this;
3214 }
3215 BOOST_UBLAS_INLINE
3216 const_iterator2 &operator += (difference_type n) {
3217 it2_ += n;
3218 return *this;
3219 }
3220 BOOST_UBLAS_INLINE
3221 const_iterator2 &operator -= (difference_type n) {
3222 it2_ -= n;
3223 return *this;
3224 }
3225 BOOST_UBLAS_INLINE
3226 difference_type operator - (const const_iterator2 &it) const {
3227 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3228 // FIXME we shouldn't compare floats
3229 // BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
3230 return it2_ - it.it2_;
3231 }
3232
3233 // Dereference
3234 BOOST_UBLAS_INLINE
3235 const_reference operator * () const {
3236 return functor_type::apply (it1_, *it2_);
3237 }
3238 BOOST_UBLAS_INLINE
3239 const_reference operator [] (difference_type n) const {
3240 return *(*this + n);
3241 }
3242
3243#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
3244 BOOST_UBLAS_INLINE
3245#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3246 typename self_type::
3247#endif
3248 const_iterator1 begin () const {
3249 return (*this) ().find1 (1, 0, index2 ());
3250 }
3251 BOOST_UBLAS_INLINE
3252#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3253 typename self_type::
3254#endif
3255 const_iterator1 cbegin () const {
3256 return begin ();
3257 }
3258 BOOST_UBLAS_INLINE
3259#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3260 typename self_type::
3261#endif
3262 const_iterator1 end () const {
3263 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
3264 }
3265 BOOST_UBLAS_INLINE
3266#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3267 typename self_type::
3268#endif
3269 const_iterator1 cend () const {
3270 return end ();
3271 }
3272 BOOST_UBLAS_INLINE
3273#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3274 typename self_type::
3275#endif
3276 const_reverse_iterator1 rbegin () const {
3277 return const_reverse_iterator1 (end ());
3278 }
3279 BOOST_UBLAS_INLINE
3280#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3281 typename self_type::
3282#endif
3283 const_reverse_iterator1 crbegin () const {
3284 return rbegin ();
3285 }
3286 BOOST_UBLAS_INLINE
3287#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3288 typename self_type::
3289#endif
3290 const_reverse_iterator1 rend () const {
3291 return const_reverse_iterator1 (begin ());
3292 }
3293 BOOST_UBLAS_INLINE
3294#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3295 typename self_type::
3296#endif
3297 const_reverse_iterator1 crend () const {
3298 return rend ();
3299 }
3300#endif
3301
3302 // Indices
3303 BOOST_UBLAS_INLINE
3304 size_type index1 () const {
3305 return it2_.index1 ();
3306 }
3307 BOOST_UBLAS_INLINE
3308 size_type index2 () const {
3309 return it2_.index2 ();
3310 }
3311
3312 // Assignment
3313 BOOST_UBLAS_INLINE
3314 const_iterator2 &operator = (const const_iterator2 &it) {
3315 container_const_reference<self_type>::assign (&it ());
3316 it1_ = it.it1_;
3317 it2_ = it.it2_;
3318 return *this;
3319 }
3320
3321 // Comparison
3322 BOOST_UBLAS_INLINE
3323 bool operator == (const const_iterator2 &it) const {
3324 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3325 // FIXME we shouldn't compare floats
3326 // BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
3327 return it2_ == it.it2_;
3328 }
3329 BOOST_UBLAS_INLINE
3330 bool operator < (const const_iterator2 &it) const {
3331 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3332 // FIXME we shouldn't compare floats
3333 // BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
3334 return it2_ < it.it2_;
3335 }
3336
3337 private:
3338 const_subiterator1_type it1_;
3339 const_iterator22_type it2_;
3340 };
3341#endif
3342
3343 BOOST_UBLAS_INLINE
3344 const_iterator2 begin2 () const {
3345 return find2 (0, 0, 0);
3346 }
3347 BOOST_UBLAS_INLINE
3348 const_iterator2 cbegin2 () const {
3349 return begin2 ();
3350 }
3351 BOOST_UBLAS_INLINE
3352 const_iterator2 end2 () const {
3353 return find2 (0, 0, size2 ());
3354 }
3355 BOOST_UBLAS_INLINE
3356 const_iterator2 cend2 () const {
3357 return end2 ();
3358 }
3359
3360 // Reverse iterators
3361
3362 BOOST_UBLAS_INLINE
3363 const_reverse_iterator1 rbegin1 () const {
3364 return const_reverse_iterator1 (end1 ());
3365 }
3366 BOOST_UBLAS_INLINE
3367 const_reverse_iterator1 crbegin1 () const {
3368 return rbegin1 ();
3369 }
3370 BOOST_UBLAS_INLINE
3371 const_reverse_iterator1 rend1 () const {
3372 return const_reverse_iterator1 (begin1 ());
3373 }
3374 BOOST_UBLAS_INLINE
3375 const_reverse_iterator1 crend1 () const {
3376 return rend1 ();
3377 }
3378
3379 BOOST_UBLAS_INLINE
3380 const_reverse_iterator2 rbegin2 () const {
3381 return const_reverse_iterator2 (end2 ());
3382 }
3383 BOOST_UBLAS_INLINE
3384 const_reverse_iterator2 crbegin2 () const {
3385 return rbegin2 ();
3386 }
3387 BOOST_UBLAS_INLINE
3388 const_reverse_iterator2 rend2 () const {
3389 return const_reverse_iterator2 (begin2 ());
3390 }
3391 BOOST_UBLAS_INLINE
3392 const_reverse_iterator2 crend2 () const {
3393 return rend2 ();
3394 }
3395
3396 private:
3397 expression1_closure_type e1_;
3398 expression2_closure_type e2_;
3399 };
3400
3401 template<class E1, class E2, class F>
3402 struct matrix_binary_scalar1_traits {
3403 typedef matrix_binary_scalar1<E1, E2, F> expression_type; // allow E1 to be builtin type
3404#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
3405 typedef expression_type result_type;
3406#else
3407 typedef typename E2::matrix_temporary_type result_type;
3408#endif
3409 };
3410
3411 // (t * m) [i] [j] = t * m [i] [j]
3412 template<class T1, class E2>
3413 BOOST_UBLAS_INLINE
3414 typename enable_if< is_convertible<T1, typename E2::value_type >,
3415 typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
3416 >::type
3417 operator * (const T1 &e1,
3418 const matrix_expression<E2> &e2) {
3419 typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::expression_type expression_type;
3420 return expression_type (e1, e2 ());
3421 }
3422
3423
3424 template<class E1, class E2, class F>
3425 class matrix_binary_scalar2:
3426 public matrix_expression<matrix_binary_scalar2<E1, E2, F> > {
3427
3428 typedef E1 expression1_type;
3429 typedef E2 expression2_type;
3430 typedef F functor_type;
3431 public:
3432 typedef typename E1::const_closure_type expression1_closure_type;
3433 typedef const E2& expression2_closure_type;
3434 private:
3435 typedef matrix_binary_scalar2<E1, E2, F> self_type;
3436 public:
3437#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
3438 using matrix_expression<self_type>::operator ();
3439#endif
3440 typedef typename E1::size_type size_type;
3441 typedef typename E1::difference_type difference_type;
3442 typedef typename F::result_type value_type;
3443 typedef value_type const_reference;
3444 typedef const_reference reference;
3445
3446 typedef const self_type const_closure_type;
3447 typedef const_closure_type closure_type;
3448 typedef typename E1::orientation_category orientation_category;
3449 typedef unknown_storage_tag storage_category;
3450
3451 // Construction and destruction
3452 BOOST_UBLAS_INLINE
3453 matrix_binary_scalar2 (const expression1_type &e1, const expression2_type &e2):
3454 e1_ (e1), e2_ (e2) {}
3455
3456 // Accessors
3457 BOOST_UBLAS_INLINE
3458 size_type size1 () const {
3459 return e1_.size1 ();
3460 }
3461 BOOST_UBLAS_INLINE
3462 size_type size2 () const {
3463 return e1_.size2 ();
3464 }
3465
3466 public:
3467 // Element access
3468 BOOST_UBLAS_INLINE
3469 const_reference operator () (size_type i, size_type j) const {
3470 return functor_type::apply (e1_ (i, j), expression2_type (e2_));
3471 }
3472
3473 // Closure comparison
3474 BOOST_UBLAS_INLINE
3475 bool same_closure (const matrix_binary_scalar2 &mbs2) const {
3476 return (*this).e1_.same_closure (mbs2.e1_) &&
3477 &e2_ == &(mbs2.e2_);
3478 }
3479
3480 // Iterator types
3481 private:
3482 typedef typename E1::const_iterator1 const_iterator11_type;
3483 typedef typename E1::const_iterator2 const_iterator12_type;
3484 typedef expression2_type const_subiterator2_type;
3485 typedef const value_type *const_pointer;
3486
3487 public:
3488#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
3489 typedef indexed_const_iterator1<const_closure_type, typename const_iterator11_type::iterator_category> const_iterator1;
3490 typedef const_iterator1 iterator1;
3491 typedef indexed_const_iterator2<const_closure_type, typename const_iterator12_type::iterator_category> const_iterator2;
3492 typedef const_iterator2 iterator2;
3493#else
3494 class const_iterator1;
3495 typedef const_iterator1 iterator1;
3496 class const_iterator2;
3497 typedef const_iterator2 iterator2;
3498#endif
3499 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
3500 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
3501
3502 // Element lookup
3503 BOOST_UBLAS_INLINE
3504 const_iterator1 find1 (int rank, size_type i, size_type j) const {
3505 const_iterator11_type it11 (e1_.find1 (rank, i, j));
3506#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
3507 return const_iterator1 (*this, it11.index1 (), it11.index2 ());
3508#else
3509 return const_iterator1 (*this, it11, const_subiterator2_type (e2_));
3510#endif
3511 }
3512 BOOST_UBLAS_INLINE
3513 const_iterator2 find2 (int rank, size_type i, size_type j) const {
3514 const_iterator12_type it12 (e1_.find2 (rank, i, j));
3515#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
3516 return const_iterator2 (*this, it12.index1 (), it12.index2 ());
3517#else
3518 return const_iterator2 (*this, it12, const_subiterator2_type (e2_));
3519#endif
3520 }
3521
3522 // Iterators enhance the iterators of the referenced expression
3523 // with the binary functor.
3524
3525#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
3526 class const_iterator1:
3527 public container_const_reference<matrix_binary_scalar2>,
3528 public iterator_base_traits<typename E1::const_iterator1::iterator_category>::template
3529 iterator_base<const_iterator1, value_type>::type {
3530 public:
3531 typedef typename E1::const_iterator1::iterator_category iterator_category;
3532 typedef typename matrix_binary_scalar2::difference_type difference_type;
3533 typedef typename matrix_binary_scalar2::value_type value_type;
3534 typedef typename matrix_binary_scalar2::const_reference reference;
3535 typedef typename matrix_binary_scalar2::const_pointer pointer;
3536
3537 typedef const_iterator2 dual_iterator_type;
3538 typedef const_reverse_iterator2 dual_reverse_iterator_type;
3539
3540 // Construction and destruction
3541 BOOST_UBLAS_INLINE
3542 const_iterator1 ():
3543 container_const_reference<self_type> (), it1_ (), it2_ () {}
3544 BOOST_UBLAS_INLINE
3545 const_iterator1 (const self_type &mbs, const const_iterator11_type &it1, const const_subiterator2_type &it2):
3546 container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}
3547
3548 // Arithmetic
3549 BOOST_UBLAS_INLINE
3550 const_iterator1 &operator ++ () {
3551 ++ it1_;
3552 return *this;
3553 }
3554 BOOST_UBLAS_INLINE
3555 const_iterator1 &operator -- () {
3556 -- it1_ ;
3557 return *this;
3558 }
3559 BOOST_UBLAS_INLINE
3560 const_iterator1 &operator += (difference_type n) {
3561 it1_ += n;
3562 return *this;
3563 }
3564 BOOST_UBLAS_INLINE
3565 const_iterator1 &operator -= (difference_type n) {
3566 it1_ -= n;
3567 return *this;
3568 }
3569 BOOST_UBLAS_INLINE
3570 difference_type operator - (const const_iterator1 &it) const {
3571 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3572 // FIXME we shouldn't compare floats
3573 // BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
3574 return it1_ - it.it1_;
3575 }
3576
3577 // Dereference
3578 BOOST_UBLAS_INLINE
3579 const_reference operator * () const {
3580 return functor_type::apply (*it1_, it2_);
3581 }
3582 BOOST_UBLAS_INLINE
3583 const_reference operator [] (difference_type n) const {
3584 return *(*this + n);
3585 }
3586
3587#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
3588 BOOST_UBLAS_INLINE
3589#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3590 typename self_type::
3591#endif
3592 const_iterator2 begin () const {
3593 return (*this) ().find2 (1, index1 (), 0);
3594 }
3595 BOOST_UBLAS_INLINE
3596#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3597 typename self_type::
3598#endif
3599 const_iterator2 cbegin () const {
3600 return begin ();
3601 }
3602 BOOST_UBLAS_INLINE
3603#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3604 typename self_type::
3605#endif
3606 const_iterator2 end () const {
3607 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
3608 }
3609 BOOST_UBLAS_INLINE
3610#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3611 typename self_type::
3612#endif
3613 const_iterator2 cend () const {
3614 return end ();
3615 }
3616 BOOST_UBLAS_INLINE
3617#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3618 typename self_type::
3619#endif
3620 const_reverse_iterator2 rbegin () const {
3621 return const_reverse_iterator2 (end ());
3622 }
3623 BOOST_UBLAS_INLINE
3624#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3625 typename self_type::
3626#endif
3627 const_reverse_iterator2 crbegin () const {
3628 return rbegin ();
3629 }
3630 BOOST_UBLAS_INLINE
3631#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3632 typename self_type::
3633#endif
3634 const_reverse_iterator2 rend () const {
3635 return const_reverse_iterator2 (begin ());
3636 }
3637 BOOST_UBLAS_INLINE
3638#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3639 typename self_type::
3640#endif
3641 const_reverse_iterator2 crend () const {
3642 return rend ();
3643 }
3644#endif
3645
3646 // Indices
3647 BOOST_UBLAS_INLINE
3648 size_type index1 () const {
3649 return it1_.index1 ();
3650 }
3651 BOOST_UBLAS_INLINE
3652 size_type index2 () const {
3653 return it1_.index2 ();
3654 }
3655
3656 // Assignment
3657 BOOST_UBLAS_INLINE
3658 const_iterator1 &operator = (const const_iterator1 &it) {
3659 container_const_reference<self_type>::assign (&it ());
3660 it1_ = it.it1_;
3661 it2_ = it.it2_;
3662 return *this;
3663 }
3664
3665 // Comparison
3666 BOOST_UBLAS_INLINE
3667 bool operator == (const const_iterator1 &it) const {
3668 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3669 // FIXME we shouldn't compare floats
3670 // BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
3671 return it1_ == it.it1_;
3672 }
3673 BOOST_UBLAS_INLINE
3674 bool operator < (const const_iterator1 &it) const {
3675 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3676 // FIXME we shouldn't compare floats
3677 // BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
3678 return it1_ < it.it1_;
3679 }
3680
3681 private:
3682 const_iterator11_type it1_;
3683 const_subiterator2_type it2_;
3684 };
3685#endif
3686
3687 BOOST_UBLAS_INLINE
3688 const_iterator1 begin1 () const {
3689 return find1 (0, 0, 0);
3690 }
3691 BOOST_UBLAS_INLINE
3692 const_iterator1 cbegin1 () const {
3693 return begin1 ();
3694 }
3695 BOOST_UBLAS_INLINE
3696 const_iterator1 end1 () const {
3697 return find1 (0, size1 (), 0);
3698 }
3699 BOOST_UBLAS_INLINE
3700 const_iterator1 cend1 () const {
3701 return end1 ();
3702 }
3703
3704#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
3705 class const_iterator2:
3706 public container_const_reference<matrix_binary_scalar2>,
3707 public iterator_base_traits<typename E1::const_iterator2::iterator_category>::template
3708 iterator_base<const_iterator2, value_type>::type {
3709 public:
3710 typedef typename E1::const_iterator2::iterator_category iterator_category;
3711 typedef typename matrix_binary_scalar2::difference_type difference_type;
3712 typedef typename matrix_binary_scalar2::value_type value_type;
3713 typedef typename matrix_binary_scalar2::const_reference reference;
3714 typedef typename matrix_binary_scalar2::const_pointer pointer;
3715
3716 typedef const_iterator1 dual_iterator_type;
3717 typedef const_reverse_iterator1 dual_reverse_iterator_type;
3718
3719 // Construction and destruction
3720 BOOST_UBLAS_INLINE
3721 const_iterator2 ():
3722 container_const_reference<self_type> (), it1_ (), it2_ () {}
3723 BOOST_UBLAS_INLINE
3724 const_iterator2 (const self_type &mbs, const const_iterator12_type &it1, const const_subiterator2_type &it2):
3725 container_const_reference<self_type> (mbs), it1_ (it1), it2_ (it2) {}
3726
3727 // Arithmetic
3728 BOOST_UBLAS_INLINE
3729 const_iterator2 &operator ++ () {
3730 ++ it1_;
3731 return *this;
3732 }
3733 BOOST_UBLAS_INLINE
3734 const_iterator2 &operator -- () {
3735 -- it1_;
3736 return *this;
3737 }
3738 BOOST_UBLAS_INLINE
3739 const_iterator2 &operator += (difference_type n) {
3740 it1_ += n;
3741 return *this;
3742 }
3743 BOOST_UBLAS_INLINE
3744 const_iterator2 &operator -= (difference_type n) {
3745 it1_ -= n;
3746 return *this;
3747 }
3748 BOOST_UBLAS_INLINE
3749 difference_type operator - (const const_iterator2 &it) const {
3750 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3751 // FIXME we shouldn't compare floats
3752 // BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
3753 return it1_ - it.it1_;
3754 }
3755
3756 // Dereference
3757 BOOST_UBLAS_INLINE
3758 const_reference operator * () const {
3759 return functor_type::apply (*it1_, it2_);
3760 }
3761 BOOST_UBLAS_INLINE
3762 const_reference operator [] (difference_type n) const {
3763 return *(*this + n);
3764 }
3765
3766#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
3767 BOOST_UBLAS_INLINE
3768#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3769 typename self_type::
3770#endif
3771 const_iterator1 begin () const {
3772 return (*this) ().find1 (1, 0, index2 ());
3773 }
3774 BOOST_UBLAS_INLINE
3775#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3776 typename self_type::
3777#endif
3778 const_iterator1 cbegin () const {
3779 return begin ();
3780 }
3781 BOOST_UBLAS_INLINE
3782#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3783 typename self_type::
3784#endif
3785 const_iterator1 end () const {
3786 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
3787 }
3788 BOOST_UBLAS_INLINE
3789#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3790 typename self_type::
3791#endif
3792 const_iterator1 cend () const {
3793 return end ();
3794 }
3795 BOOST_UBLAS_INLINE
3796#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3797 typename self_type::
3798#endif
3799 const_reverse_iterator1 rbegin () const {
3800 return const_reverse_iterator1 (end ());
3801 }
3802 BOOST_UBLAS_INLINE
3803#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3804 typename self_type::
3805#endif
3806 const_reverse_iterator1 crbegin () const {
3807 return rbegin ();
3808 }
3809 BOOST_UBLAS_INLINE
3810#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3811 typename self_type::
3812#endif
3813 const_reverse_iterator1 rend () const {
3814 return const_reverse_iterator1 (begin ());
3815 }
3816 BOOST_UBLAS_INLINE
3817#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
3818 typename self_type::
3819#endif
3820 const_reverse_iterator1 crend () const {
3821 return rend ();
3822 }
3823#endif
3824
3825 // Indices
3826 BOOST_UBLAS_INLINE
3827 size_type index1 () const {
3828 return it1_.index1 ();
3829 }
3830 BOOST_UBLAS_INLINE
3831 size_type index2 () const {
3832 return it1_.index2 ();
3833 }
3834
3835 // Assignment
3836 BOOST_UBLAS_INLINE
3837 const_iterator2 &operator = (const const_iterator2 &it) {
3838 container_const_reference<self_type>::assign (&it ());
3839 it1_ = it.it1_;
3840 it2_ = it.it2_;
3841 return *this;
3842 }
3843
3844 // Comparison
3845 BOOST_UBLAS_INLINE
3846 bool operator == (const const_iterator2 &it) const {
3847 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3848 // FIXME we shouldn't compare floats
3849 // BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
3850 return it1_ == it.it1_;
3851 }
3852 BOOST_UBLAS_INLINE
3853 bool operator < (const const_iterator2 &it) const {
3854 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
3855 // FIXME we shouldn't compare floats
3856 // BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
3857 return it1_ < it.it1_;
3858 }
3859
3860 private:
3861 const_iterator12_type it1_;
3862 const_subiterator2_type it2_;
3863 };
3864#endif
3865
3866 BOOST_UBLAS_INLINE
3867 const_iterator2 begin2 () const {
3868 return find2 (0, 0, 0);
3869 }
3870 BOOST_UBLAS_INLINE
3871 const_iterator2 cbegin2 () const {
3872 return begin2 ();
3873 }
3874 BOOST_UBLAS_INLINE
3875 const_iterator2 end2 () const {
3876 return find2 (0, 0, size2 ());
3877 }
3878 BOOST_UBLAS_INLINE
3879 const_iterator2 cend2 () const {
3880 return end2 ();
3881 }
3882
3883 // Reverse iterators
3884
3885 BOOST_UBLAS_INLINE
3886 const_reverse_iterator1 rbegin1 () const {
3887 return const_reverse_iterator1 (end1 ());
3888 }
3889 BOOST_UBLAS_INLINE
3890 const_reverse_iterator1 crbegin1 () const {
3891 return rbegin1 ();
3892 }
3893 BOOST_UBLAS_INLINE
3894 const_reverse_iterator1 rend1 () const {
3895 return const_reverse_iterator1 (begin1 ());
3896 }
3897 BOOST_UBLAS_INLINE
3898 const_reverse_iterator1 crend1 () const {
3899 return rend1 ();
3900 }
3901
3902 BOOST_UBLAS_INLINE
3903 const_reverse_iterator2 rbegin2 () const {
3904 return const_reverse_iterator2 (end2 ());
3905 }
3906 BOOST_UBLAS_INLINE
3907 const_reverse_iterator2 crbegin2 () const {
3908 return rbegin2 ();
3909 }
3910 BOOST_UBLAS_INLINE
3911 const_reverse_iterator2 rend2 () const {
3912 return const_reverse_iterator2 (begin2 ());
3913 }
3914 BOOST_UBLAS_INLINE
3915 const_reverse_iterator2 crend2 () const {
3916 return rend2 ();
3917 }
3918
3919 private:
3920 expression1_closure_type e1_;
3921 expression2_closure_type e2_;
3922 };
3923
3924 template<class E1, class E2, class F>
3925 struct matrix_binary_scalar2_traits {
3926 typedef matrix_binary_scalar2<E1, E2, F> expression_type; // allow E2 to be builtin type
3927#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
3928 typedef expression_type result_type;
3929#else
3930 typedef typename E1::matrix_temporary_type result_type;
3931#endif
3932 };
3933
3934 // (m * t) [i] [j] = m [i] [j] * t
3935 template<class E1, class T2>
3936 BOOST_UBLAS_INLINE
3937 typename enable_if< is_convertible<T2, typename E1::value_type>,
3938 typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
3939 >::type
3940 operator * (const matrix_expression<E1> &e1,
3941 const T2 &e2) {
3942 typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::expression_type expression_type;
3943 return expression_type (e1 (), e2);
3944 }
3945
3946 // (m / t) [i] [j] = m [i] [j] / t
3947 template<class E1, class T2>
3948 BOOST_UBLAS_INLINE
3949 typename enable_if< is_convertible<T2, typename E1::value_type>,
3950 typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
3951 >::type
3952 operator / (const matrix_expression<E1> &e1,
3953 const T2 &e2) {
3954 typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::expression_type expression_type;
3955 return expression_type (e1 (), e2);
3956 }
3957
3958
3959 template<class E1, class E2, class F>
3960 class matrix_vector_binary1:
3961 public vector_expression<matrix_vector_binary1<E1, E2, F> > {
3962
3963 public:
3964 typedef E1 expression1_type;
3965 typedef E2 expression2_type;
3966 private:
3967 typedef F functor_type;
3968 public:
3969 typedef typename E1::const_closure_type expression1_closure_type;
3970 typedef typename E2::const_closure_type expression2_closure_type;
3971 private:
3972 typedef matrix_vector_binary1<E1, E2, F> self_type;
3973 public:
3974#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
3975 using vector_expression<self_type>::operator ();
3976#endif
3977 static const unsigned complexity = 1;
3978 typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
3979 typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
3980 typedef typename F::result_type value_type;
3981 typedef value_type const_reference;
3982 typedef const_reference reference;
3983 typedef const self_type const_closure_type;
3984 typedef const_closure_type closure_type;
3985 typedef unknown_storage_tag storage_category;
3986
3987 // Construction and destruction
3988 BOOST_UBLAS_INLINE
3989 matrix_vector_binary1 (const expression1_type &e1, const expression2_type &e2):
3990 e1_ (e1), e2_ (e2) {}
3991
3992 // Accessors
3993 BOOST_UBLAS_INLINE
3994 size_type size () const {
3995 return e1_.size1 ();
3996 }
3997
3998 public:
3999 // Expression accessors
4000 BOOST_UBLAS_INLINE
4001 const expression1_closure_type &expression1 () const {
4002 return e1_;
4003 }
4004 BOOST_UBLAS_INLINE
4005 const expression2_closure_type &expression2 () const {
4006 return e2_;
4007 }
4008
4009 public:
4010 // Element access
4011 BOOST_UBLAS_INLINE
4012 const_reference operator () (size_type i) const {
4013 return functor_type::apply (e1_, e2_, i);
4014 }
4015
4016 // Closure comparison
4017 BOOST_UBLAS_INLINE
4018 bool same_closure (const matrix_vector_binary1 &mvb1) const {
4019 return (*this).expression1 ().same_closure (mvb1.expression1 ()) &&
4020 (*this).expression2 ().same_closure (mvb1.expression2 ());
4021 }
4022
4023 // Iterator types
4024 private:
4025 typedef typename E1::const_iterator1 const_subiterator1_type;
4026 typedef typename E2::const_iterator const_subiterator2_type;
4027 typedef const value_type *const_pointer;
4028
4029 public:
4030#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4031 typedef indexed_const_iterator<const_closure_type, typename const_subiterator1_type::iterator_category> const_iterator;
4032 typedef const_iterator iterator;
4033#else
4034 class const_iterator;
4035 typedef const_iterator iterator;
4036#endif
4037
4038 // Element lookup
4039 BOOST_UBLAS_INLINE
4040 const_iterator find (size_type i) const {
4041#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4042 const_subiterator1_type it1 (e1_.find1 (0, i, 0));
4043 return const_iterator (*this, it1.index1 ());
4044#else
4045 return const_iterator (*this, e1_.find1 (0, i, 0));
4046#endif
4047 }
4048
4049
4050#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
4051 class const_iterator:
4052 public container_const_reference<matrix_vector_binary1>,
4053 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
4054 typename E2::const_iterator::iterator_category>::iterator_category>::template
4055 iterator_base<const_iterator, value_type>::type {
4056 public:
4057 typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
4058 typename E2::const_iterator::iterator_category>::iterator_category iterator_category;
4059 typedef typename matrix_vector_binary1::difference_type difference_type;
4060 typedef typename matrix_vector_binary1::value_type value_type;
4061 typedef typename matrix_vector_binary1::const_reference reference;
4062 typedef typename matrix_vector_binary1::const_pointer pointer;
4063
4064 // Construction and destruction
4065#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4066 BOOST_UBLAS_INLINE
4067 const_iterator ():
4068 container_const_reference<self_type> (), it1_ (), e2_begin_ (), e2_end_ () {}
4069 BOOST_UBLAS_INLINE
4070 const_iterator (const self_type &mvb, const const_subiterator1_type &it1):
4071 container_const_reference<self_type> (mvb), it1_ (it1), e2_begin_ (mvb.expression2 ().begin ()), e2_end_ (mvb.expression2 ().end ()) {}
4072#else
4073 BOOST_UBLAS_INLINE
4074 const_iterator ():
4075 container_const_reference<self_type> (), it1_ () {}
4076 BOOST_UBLAS_INLINE
4077 const_iterator (const self_type &mvb, const const_subiterator1_type &it1):
4078 container_const_reference<self_type> (mvb), it1_ (it1) {}
4079#endif
4080
4081 private:
4082 // Dense random access specialization
4083 BOOST_UBLAS_INLINE
4084 value_type dereference (dense_random_access_iterator_tag) const {
4085 const self_type &mvb = (*this) ();
4086#ifdef BOOST_UBLAS_USE_INDEXING
4087 return mvb (index ());
4088#elif BOOST_UBLAS_USE_ITERATING
4089 difference_type size = BOOST_UBLAS_SAME (mvb.expression1 ().size2 (), mvb.expression2 ().size ());
4090#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4091 return functor_type::apply (size, it1_.begin (), e2_begin_);
4092#else
4093 return functor_type::apply (size, it1_.begin (), mvb.expression2 ().begin ());
4094#endif
4095#else
4096 difference_type size = BOOST_UBLAS_SAME (mvb.expression1 ().size2 (), mvb.expression2 ().size ());
4097 if (size >= BOOST_UBLAS_ITERATOR_THRESHOLD)
4098#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4099 return functor_type::apply (size, it1_.begin (), e2_begin_);
4100#else
4101 return functor_type::apply (size, it1_.begin (), mvb.expression2 ().begin ());
4102#endif
4103 else
4104 return mvb (index ());
4105#endif
4106 }
4107
4108 // Packed bidirectional specialization
4109 BOOST_UBLAS_INLINE
4110 value_type dereference (packed_random_access_iterator_tag) const {
4111#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4112 return functor_type::apply (it1_.begin (), it1_.end (), e2_begin_, e2_end_);
4113#else
4114 const self_type &mvb = (*this) ();
4115#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
4116 return functor_type::apply (it1_.begin (), it1_.end (),
4117 mvb.expression2 ().begin (), mvb.expression2 ().end ());
4118#else
4119 return functor_type::apply (boost::numeric::ublas::begin (it1_, iterator1_tag ()),
4120 boost::numeric::ublas::end (it1_, iterator1_tag ()),
4121 mvb.expression2 ().begin (), mvb.expression2 ().end ());
4122#endif
4123#endif
4124 }
4125
4126 // Sparse bidirectional specialization
4127 BOOST_UBLAS_INLINE
4128 value_type dereference (sparse_bidirectional_iterator_tag) const {
4129#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4130 return functor_type::apply (it1_.begin (), it1_.end (), e2_begin_, e2_end_, sparse_bidirectional_iterator_tag ());
4131#else
4132 const self_type &mvb = (*this) ();
4133#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
4134 return functor_type::apply (it1_.begin (), it1_.end (),
4135 mvb.expression2 ().begin (), mvb.expression2 ().end (), sparse_bidirectional_iterator_tag ());
4136#else
4137 return functor_type::apply (boost::numeric::ublas::begin (it1_, iterator1_tag ()),
4138 boost::numeric::ublas::end (it1_, iterator1_tag ()),
4139 mvb.expression2 ().begin (), mvb.expression2 ().end (), sparse_bidirectional_iterator_tag ());
4140#endif
4141#endif
4142 }
4143
4144 public:
4145 // Arithmetic
4146 BOOST_UBLAS_INLINE
4147 const_iterator &operator ++ () {
4148 ++ it1_;
4149 return *this;
4150 }
4151 BOOST_UBLAS_INLINE
4152 const_iterator &operator -- () {
4153 -- it1_;
4154 return *this;
4155 }
4156 BOOST_UBLAS_INLINE
4157 const_iterator &operator += (difference_type n) {
4158 it1_ += n;
4159 return *this;
4160 }
4161 BOOST_UBLAS_INLINE
4162 const_iterator &operator -= (difference_type n) {
4163 it1_ -= n;
4164 return *this;
4165 }
4166 BOOST_UBLAS_INLINE
4167 difference_type operator - (const const_iterator &it) const {
4168 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
4169 return it1_ - it.it1_;
4170 }
4171
4172 // Dereference
4173 BOOST_UBLAS_INLINE
4174 const_reference operator * () const {
4175 return dereference (iterator_category ());
4176 }
4177 BOOST_UBLAS_INLINE
4178 const_reference operator [] (difference_type n) const {
4179 return *(*this + n);
4180 }
4181
4182 // Index
4183 BOOST_UBLAS_INLINE
4184 size_type index () const {
4185 return it1_.index1 ();
4186 }
4187
4188 // Assignment
4189 BOOST_UBLAS_INLINE
4190 const_iterator &operator = (const const_iterator &it) {
4191 container_const_reference<self_type>::assign (&it ());
4192 it1_ = it.it1_;
4193#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4194 e2_begin_ = it.e2_begin_;
4195 e2_end_ = it.e2_end_;
4196#endif
4197 return *this;
4198 }
4199
4200 // Comparison
4201 BOOST_UBLAS_INLINE
4202 bool operator == (const const_iterator &it) const {
4203 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
4204 return it1_ == it.it1_;
4205 }
4206 BOOST_UBLAS_INLINE
4207 bool operator < (const const_iterator &it) const {
4208 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
4209 return it1_ < it.it1_;
4210 }
4211
4212 private:
4213 const_subiterator1_type it1_;
4214#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4215 // Mutable due to assignment
4216 /* const */ const_subiterator2_type e2_begin_;
4217 /* const */ const_subiterator2_type e2_end_;
4218#endif
4219 };
4220#endif
4221
4222 BOOST_UBLAS_INLINE
4223 const_iterator begin () const {
4224 return find (0);
4225 }
4226 BOOST_UBLAS_INLINE
4227 const_iterator cbegin () const {
4228 return begin ();
4229 }
4230 BOOST_UBLAS_INLINE
4231 const_iterator end () const {
4232 return find (size ());
4233 }
4234 BOOST_UBLAS_INLINE
4235 const_iterator cend () const {
4236 return end ();
4237 }
4238
4239 // Reverse iterator
4240 typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
4241
4242 BOOST_UBLAS_INLINE
4243 const_reverse_iterator rbegin () const {
4244 return const_reverse_iterator (end ());
4245 }
4246 BOOST_UBLAS_INLINE
4247 const_reverse_iterator crbegin () const {
4248 return rbegin ();
4249 }
4250 BOOST_UBLAS_INLINE
4251 const_reverse_iterator rend () const {
4252 return const_reverse_iterator (begin ());
4253 }
4254 BOOST_UBLAS_INLINE
4255 const_reverse_iterator crend () const {
4256 return rend ();
4257 }
4258
4259 private:
4260 expression1_closure_type e1_;
4261 expression2_closure_type e2_;
4262 };
4263
4264 template<class T1, class E1, class T2, class E2>
4265 struct matrix_vector_binary1_traits {
4266 typedef unknown_storage_tag storage_category;
4267 typedef row_major_tag orientation_category;
4268 typedef typename promote_traits<T1, T2>::promote_type promote_type;
4269 typedef matrix_vector_binary1<E1, E2, matrix_vector_prod1<E1, E2, promote_type> > expression_type;
4270#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
4271 typedef expression_type result_type;
4272#else
4273 typedef typename E1::vector_temporary_type result_type;
4274#endif
4275 };
4276
4277 template<class E1, class E2>
4278 BOOST_UBLAS_INLINE
4279 typename matrix_vector_binary1_traits<typename E1::value_type, E1,
4280 typename E2::value_type, E2>::result_type
4281 prod (const matrix_expression<E1> &e1,
4282 const vector_expression<E2> &e2,
4283 unknown_storage_tag,
4284 row_major_tag) {
4285 typedef typename matrix_vector_binary1_traits<typename E1::value_type, E1,
4286 typename E2::value_type, E2>::expression_type expression_type;
4287 return expression_type (e1 (), e2 ());
4288 }
4289
4290 // Dispatcher
4291 template<class E1, class E2>
4292 BOOST_UBLAS_INLINE
4293 typename matrix_vector_binary1_traits<typename E1::value_type, E1,
4294 typename E2::value_type, E2>::result_type
4295 prod (const matrix_expression<E1> &e1,
4296 const vector_expression<E2> &e2) {
4297 BOOST_STATIC_ASSERT (E2::complexity == 0);
4298 typedef typename matrix_vector_binary1_traits<typename E1::value_type, E1,
4299 typename E2::value_type, E2>::storage_category storage_category;
4300 typedef typename matrix_vector_binary1_traits<typename E1::value_type, E1,
4301 typename E2::value_type, E2>::orientation_category orientation_category;
4302 return prod (e1, e2, storage_category (), orientation_category ());
4303 }
4304
4305 template<class E1, class E2>
4306 BOOST_UBLAS_INLINE
4307 typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4308 typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
4309 prec_prod (const matrix_expression<E1> &e1,
4310 const vector_expression<E2> &e2,
4311 unknown_storage_tag,
4312 row_major_tag) {
4313 typedef typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4314 typename type_traits<typename E2::value_type>::precision_type, E2>::expression_type expression_type;
4315 return expression_type (e1 (), e2 ());
4316 }
4317
4318 // Dispatcher
4319 template<class E1, class E2>
4320 BOOST_UBLAS_INLINE
4321 typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4322 typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
4323 prec_prod (const matrix_expression<E1> &e1,
4324 const vector_expression<E2> &e2) {
4325 BOOST_STATIC_ASSERT (E2::complexity == 0);
4326 typedef typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4327 typename type_traits<typename E2::value_type>::precision_type, E2>::storage_category storage_category;
4328 typedef typename matrix_vector_binary1_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4329 typename type_traits<typename E2::value_type>::precision_type, E2>::orientation_category orientation_category;
4330 return prec_prod (e1, e2, storage_category (), orientation_category ());
4331 }
4332
4333 template<class V, class E1, class E2>
4334 BOOST_UBLAS_INLINE
4335 V &
4336 prod (const matrix_expression<E1> &e1,
4337 const vector_expression<E2> &e2,
4338 V &v) {
4339 return v.assign (prod (e1, e2));
4340 }
4341
4342 template<class V, class E1, class E2>
4343 BOOST_UBLAS_INLINE
4344 V &
4345 prec_prod (const matrix_expression<E1> &e1,
4346 const vector_expression<E2> &e2,
4347 V &v) {
4348 return v.assign (prec_prod (e1, e2));
4349 }
4350
4351 template<class V, class E1, class E2>
4352 BOOST_UBLAS_INLINE
4353 V
4354 prod (const matrix_expression<E1> &e1,
4355 const vector_expression<E2> &e2) {
4356 return V (prod (e1, e2));
4357 }
4358
4359 template<class V, class E1, class E2>
4360 BOOST_UBLAS_INLINE
4361 V
4362 prec_prod (const matrix_expression<E1> &e1,
4363 const vector_expression<E2> &e2) {
4364 return V (prec_prod (e1, e2));
4365 }
4366
4367 template<class E1, class E2, class F>
4368 class matrix_vector_binary2:
4369 public vector_expression<matrix_vector_binary2<E1, E2, F> > {
4370
4371 typedef E1 expression1_type;
4372 typedef E2 expression2_type;
4373 typedef F functor_type;
4374 public:
4375 typedef typename E1::const_closure_type expression1_closure_type;
4376 typedef typename E2::const_closure_type expression2_closure_type;
4377 private:
4378 typedef matrix_vector_binary2<E1, E2, F> self_type;
4379 public:
4380#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
4381 using vector_expression<self_type>::operator ();
4382#endif
4383 static const unsigned complexity = 1;
4384 typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
4385 typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
4386 typedef typename F::result_type value_type;
4387 typedef value_type const_reference;
4388 typedef const_reference reference;
4389 typedef const self_type const_closure_type;
4390 typedef const_closure_type closure_type;
4391 typedef unknown_storage_tag storage_category;
4392
4393 // Construction and destruction
4394 BOOST_UBLAS_INLINE
4395 matrix_vector_binary2 (const expression1_type &e1, const expression2_type &e2):
4396 e1_ (e1), e2_ (e2) {}
4397
4398 // Accessors
4399 BOOST_UBLAS_INLINE
4400 size_type size () const {
4401 return e2_.size2 ();
4402 }
4403
4404 public:
4405 // Expression accessors
4406 BOOST_UBLAS_INLINE
4407 const expression1_closure_type &expression1 () const {
4408 return e1_;
4409 }
4410 BOOST_UBLAS_INLINE
4411 const expression2_closure_type &expression2 () const {
4412 return e2_;
4413 }
4414 public:
4415
4416 // Element access
4417 BOOST_UBLAS_INLINE
4418 const_reference operator () (size_type j) const {
4419 return functor_type::apply (e1_, e2_, j);
4420 }
4421
4422 // Closure comparison
4423 BOOST_UBLAS_INLINE
4424 bool same_closure (const matrix_vector_binary2 &mvb2) const {
4425 return (*this).expression1 ().same_closure (mvb2.expression1 ()) &&
4426 (*this).expression2 ().same_closure (mvb2.expression2 ());
4427 }
4428
4429 // Iterator types
4430 private:
4431 typedef typename E1::const_iterator const_subiterator1_type;
4432 typedef typename E2::const_iterator2 const_subiterator2_type;
4433 typedef const value_type *const_pointer;
4434
4435 public:
4436#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4437 typedef indexed_const_iterator<const_closure_type, typename const_subiterator2_type::iterator_category> const_iterator;
4438 typedef const_iterator iterator;
4439#else
4440 class const_iterator;
4441 typedef const_iterator iterator;
4442#endif
4443
4444 // Element lookup
4445 BOOST_UBLAS_INLINE
4446 const_iterator find (size_type j) const {
4447#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4448 const_subiterator2_type it2 (e2_.find2 (0, 0, j));
4449 return const_iterator (*this, it2.index2 ());
4450#else
4451 return const_iterator (*this, e2_.find2 (0, 0, j));
4452#endif
4453 }
4454
4455
4456#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
4457 class const_iterator:
4458 public container_const_reference<matrix_vector_binary2>,
4459 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
4460 typename E2::const_iterator2::iterator_category>::iterator_category>::template
4461 iterator_base<const_iterator, value_type>::type {
4462 public:
4463 typedef typename iterator_restrict_traits<typename E1::const_iterator::iterator_category,
4464 typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
4465 typedef typename matrix_vector_binary2::difference_type difference_type;
4466 typedef typename matrix_vector_binary2::value_type value_type;
4467 typedef typename matrix_vector_binary2::const_reference reference;
4468 typedef typename matrix_vector_binary2::const_pointer pointer;
4469
4470 // Construction and destruction
4471#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4472 BOOST_UBLAS_INLINE
4473 const_iterator ():
4474 container_const_reference<self_type> (), it2_ (), e1_begin_ (), e1_end_ () {}
4475 BOOST_UBLAS_INLINE
4476 const_iterator (const self_type &mvb, const const_subiterator2_type &it2):
4477 container_const_reference<self_type> (mvb), it2_ (it2), e1_begin_ (mvb.expression1 ().begin ()), e1_end_ (mvb.expression1 ().end ()) {}
4478#else
4479 BOOST_UBLAS_INLINE
4480 const_iterator ():
4481 container_const_reference<self_type> (), it2_ () {}
4482 BOOST_UBLAS_INLINE
4483 const_iterator (const self_type &mvb, const const_subiterator2_type &it2):
4484 container_const_reference<self_type> (mvb), it2_ (it2) {}
4485#endif
4486
4487 private:
4488 // Dense random access specialization
4489 BOOST_UBLAS_INLINE
4490 value_type dereference (dense_random_access_iterator_tag) const {
4491 const self_type &mvb = (*this) ();
4492#ifdef BOOST_UBLAS_USE_INDEXING
4493 return mvb (index ());
4494#elif BOOST_UBLAS_USE_ITERATING
4495 difference_type size = BOOST_UBLAS_SAME (mvb.expression2 ().size1 (), mvb.expression1 ().size ());
4496#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4497 return functor_type::apply (size, e1_begin_, it2_.begin ());
4498#else
4499 return functor_type::apply (size, mvb.expression1 ().begin (), it2_.begin ());
4500#endif
4501#else
4502 difference_type size = BOOST_UBLAS_SAME (mvb.expression2 ().size1 (), mvb.expression1 ().size ());
4503 if (size >= BOOST_UBLAS_ITERATOR_THRESHOLD)
4504#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4505 return functor_type::apply (size, e1_begin_, it2_.begin ());
4506#else
4507 return functor_type::apply (size, mvb.expression1 ().begin (), it2_.begin ());
4508#endif
4509 else
4510 return mvb (index ());
4511#endif
4512 }
4513
4514 // Packed bidirectional specialization
4515 BOOST_UBLAS_INLINE
4516 value_type dereference (packed_random_access_iterator_tag) const {
4517#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4518 return functor_type::apply (e1_begin_, e1_end_, it2_.begin (), it2_.end ());
4519#else
4520 const self_type &mvb = (*this) ();
4521#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
4522 return functor_type::apply (mvb.expression1 ().begin (), mvb.expression1 ().end (),
4523 it2_.begin (), it2_.end ());
4524#else
4525 return functor_type::apply (mvb.expression1 ().begin (), mvb.expression1 ().end (),
4526 boost::numeric::ublas::begin (it2_, iterator2_tag ()),
4527 boost::numeric::ublas::end (it2_, iterator2_tag ()));
4528#endif
4529#endif
4530 }
4531
4532 // Sparse bidirectional specialization
4533 BOOST_UBLAS_INLINE
4534 value_type dereference (sparse_bidirectional_iterator_tag) const {
4535#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4536 return functor_type::apply (e1_begin_, e1_end_, it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());
4537#else
4538 const self_type &mvb = (*this) ();
4539#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
4540 return functor_type::apply (mvb.expression1 ().begin (), mvb.expression1 ().end (),
4541 it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());
4542#else
4543 return functor_type::apply (mvb.expression1 ().begin (), mvb.expression1 ().end (),
4544 boost::numeric::ublas::begin (it2_, iterator2_tag ()),
4545 boost::numeric::ublas::end (it2_, iterator2_tag ()), sparse_bidirectional_iterator_tag ());
4546#endif
4547#endif
4548 }
4549
4550 public:
4551 // Arithmetic
4552 BOOST_UBLAS_INLINE
4553 const_iterator &operator ++ () {
4554 ++ it2_;
4555 return *this;
4556 }
4557 BOOST_UBLAS_INLINE
4558 const_iterator &operator -- () {
4559 -- it2_;
4560 return *this;
4561 }
4562 BOOST_UBLAS_INLINE
4563 const_iterator &operator += (difference_type n) {
4564 it2_ += n;
4565 return *this;
4566 }
4567 BOOST_UBLAS_INLINE
4568 const_iterator &operator -= (difference_type n) {
4569 it2_ -= n;
4570 return *this;
4571 }
4572 BOOST_UBLAS_INLINE
4573 difference_type operator - (const const_iterator &it) const {
4574 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
4575 return it2_ - it.it2_;
4576 }
4577
4578 // Dereference
4579 BOOST_UBLAS_INLINE
4580 const_reference operator * () const {
4581 return dereference (iterator_category ());
4582 }
4583 BOOST_UBLAS_INLINE
4584 const_reference operator [] (difference_type n) const {
4585 return *(*this + n);
4586 }
4587
4588 // Index
4589 BOOST_UBLAS_INLINE
4590 size_type index () const {
4591 return it2_.index2 ();
4592 }
4593
4594 // Assignment
4595 BOOST_UBLAS_INLINE
4596 const_iterator &operator = (const const_iterator &it) {
4597 container_const_reference<self_type>::assign (&it ());
4598 it2_ = it.it2_;
4599#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4600 e1_begin_ = it.e1_begin_;
4601 e1_end_ = it.e1_end_;
4602#endif
4603 return *this;
4604 }
4605
4606 // Comparison
4607 BOOST_UBLAS_INLINE
4608 bool operator == (const const_iterator &it) const {
4609 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
4610 return it2_ == it.it2_;
4611 }
4612 BOOST_UBLAS_INLINE
4613 bool operator < (const const_iterator &it) const {
4614 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
4615 return it2_ < it.it2_;
4616 }
4617
4618 private:
4619 const_subiterator2_type it2_;
4620#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4621 // Mutable due to assignment
4622 /* const */ const_subiterator1_type e1_begin_;
4623 /* const */ const_subiterator1_type e1_end_;
4624#endif
4625 };
4626#endif
4627
4628 BOOST_UBLAS_INLINE
4629 const_iterator begin () const {
4630 return find (0);
4631 }
4632 BOOST_UBLAS_INLINE
4633 const_iterator cbegin () const {
4634 return begin ();
4635 }
4636 BOOST_UBLAS_INLINE
4637 const_iterator end () const {
4638 return find (size ());
4639 }
4640 BOOST_UBLAS_INLINE
4641 const_iterator cend () const {
4642 return end ();
4643 }
4644
4645 // Reverse iterator
4646 typedef reverse_iterator_base<const_iterator> const_reverse_iterator;
4647
4648 BOOST_UBLAS_INLINE
4649 const_reverse_iterator rbegin () const {
4650 return const_reverse_iterator (end ());
4651 }
4652 BOOST_UBLAS_INLINE
4653 const_reverse_iterator crbegin () const {
4654 return rbegin ();
4655 }
4656 BOOST_UBLAS_INLINE
4657 const_reverse_iterator rend () const {
4658 return const_reverse_iterator (begin ());
4659 }
4660 BOOST_UBLAS_INLINE
4661 const_reverse_iterator crend () const {
4662 return rend ();
4663 }
4664
4665 private:
4666 expression1_closure_type e1_;
4667 expression2_closure_type e2_;
4668 };
4669
4670 template<class T1, class E1, class T2, class E2>
4671 struct matrix_vector_binary2_traits {
4672 typedef unknown_storage_tag storage_category;
4673 typedef column_major_tag orientation_category;
4674 typedef typename promote_traits<T1, T2>::promote_type promote_type;
4675 typedef matrix_vector_binary2<E1, E2, matrix_vector_prod2<E1, E2, promote_type> > expression_type;
4676#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
4677 typedef expression_type result_type;
4678#else
4679 typedef typename E2::vector_temporary_type result_type;
4680#endif
4681 };
4682
4683 template<class E1, class E2>
4684 BOOST_UBLAS_INLINE
4685 typename matrix_vector_binary2_traits<typename E1::value_type, E1,
4686 typename E2::value_type, E2>::result_type
4687 prod (const vector_expression<E1> &e1,
4688 const matrix_expression<E2> &e2,
4689 unknown_storage_tag,
4690 column_major_tag) {
4691 typedef typename matrix_vector_binary2_traits<typename E1::value_type, E1,
4692 typename E2::value_type, E2>::expression_type expression_type;
4693 return expression_type (e1 (), e2 ());
4694 }
4695
4696 // Dispatcher
4697 template<class E1, class E2>
4698 BOOST_UBLAS_INLINE
4699 typename matrix_vector_binary2_traits<typename E1::value_type, E1,
4700 typename E2::value_type, E2>::result_type
4701 prod (const vector_expression<E1> &e1,
4702 const matrix_expression<E2> &e2) {
4703 BOOST_STATIC_ASSERT (E1::complexity == 0);
4704 typedef typename matrix_vector_binary2_traits<typename E1::value_type, E1,
4705 typename E2::value_type, E2>::storage_category storage_category;
4706 typedef typename matrix_vector_binary2_traits<typename E1::value_type, E1,
4707 typename E2::value_type, E2>::orientation_category orientation_category;
4708 return prod (e1, e2, storage_category (), orientation_category ());
4709 }
4710
4711 template<class E1, class E2>
4712 BOOST_UBLAS_INLINE
4713 typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4714 typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
4715 prec_prod (const vector_expression<E1> &e1,
4716 const matrix_expression<E2> &e2,
4717 unknown_storage_tag,
4718 column_major_tag) {
4719 typedef typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4720 typename type_traits<typename E2::value_type>::precision_type, E2>::expression_type expression_type;
4721 return expression_type (e1 (), e2 ());
4722 }
4723
4724 // Dispatcher
4725 template<class E1, class E2>
4726 BOOST_UBLAS_INLINE
4727 typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4728 typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
4729 prec_prod (const vector_expression<E1> &e1,
4730 const matrix_expression<E2> &e2) {
4731 BOOST_STATIC_ASSERT (E1::complexity == 0);
4732 typedef typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4733 typename type_traits<typename E2::value_type>::precision_type, E2>::storage_category storage_category;
4734 typedef typename matrix_vector_binary2_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
4735 typename type_traits<typename E2::value_type>::precision_type, E2>::orientation_category orientation_category;
4736 return prec_prod (e1, e2, storage_category (), orientation_category ());
4737 }
4738
4739 template<class V, class E1, class E2>
4740 BOOST_UBLAS_INLINE
4741 V &
4742 prod (const vector_expression<E1> &e1,
4743 const matrix_expression<E2> &e2,
4744 V &v) {
4745 return v.assign (prod (e1, e2));
4746 }
4747
4748 template<class V, class E1, class E2>
4749 BOOST_UBLAS_INLINE
4750 V &
4751 prec_prod (const vector_expression<E1> &e1,
4752 const matrix_expression<E2> &e2,
4753 V &v) {
4754 return v.assign (prec_prod (e1, e2));
4755 }
4756
4757 template<class V, class E1, class E2>
4758 BOOST_UBLAS_INLINE
4759 V
4760 prod (const vector_expression<E1> &e1,
4761 const matrix_expression<E2> &e2) {
4762 return V (prod (e1, e2));
4763 }
4764
4765 template<class V, class E1, class E2>
4766 BOOST_UBLAS_INLINE
4767 V
4768 prec_prod (const vector_expression<E1> &e1,
4769 const matrix_expression<E2> &e2) {
4770 return V (prec_prod (e1, e2));
4771 }
4772
4773 template<class E1, class E2, class F>
4774 class matrix_matrix_binary:
4775 public matrix_expression<matrix_matrix_binary<E1, E2, F> > {
4776
4777 public:
4778 typedef E1 expression1_type;
4779 typedef E2 expression2_type;
4780 private:
4781 typedef F functor_type;
4782 public:
4783 typedef typename E1::const_closure_type expression1_closure_type;
4784 typedef typename E2::const_closure_type expression2_closure_type;
4785 private:
4786 typedef matrix_matrix_binary<E1, E2, F> self_type;
4787 public:
4788#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
4789 using matrix_expression<self_type>::operator ();
4790#endif
4791 static const unsigned complexity = 1;
4792 typedef typename promote_traits<typename E1::size_type, typename E2::size_type>::promote_type size_type;
4793 typedef typename promote_traits<typename E1::difference_type, typename E2::difference_type>::promote_type difference_type;
4794 typedef typename F::result_type value_type;
4795 typedef value_type const_reference;
4796 typedef const_reference reference;
4797 typedef const self_type const_closure_type;
4798 typedef const_closure_type closure_type;
4799 typedef unknown_orientation_tag orientation_category;
4800 typedef unknown_storage_tag storage_category;
4801
4802 // Construction and destruction
4803 BOOST_UBLAS_INLINE
4804 matrix_matrix_binary (const expression1_type &e1, const expression2_type &e2):
4805 e1_ (e1), e2_ (e2) {}
4806
4807 // Accessors
4808 BOOST_UBLAS_INLINE
4809 size_type size1 () const {
4810 return e1_.size1 ();
4811 }
4812 BOOST_UBLAS_INLINE
4813 size_type size2 () const {
4814 return e2_.size2 ();
4815 }
4816
4817 public:
4818 // Expression accessors
4819 BOOST_UBLAS_INLINE
4820 const expression1_closure_type &expression1 () const {
4821 return e1_;
4822 }
4823 BOOST_UBLAS_INLINE
4824 const expression2_closure_type &expression2 () const {
4825 return e2_;
4826 }
4827
4828 public:
4829 // Element access
4830 BOOST_UBLAS_INLINE
4831 const_reference operator () (size_type i, size_type j) const {
4832 return functor_type::apply (e1_, e2_, i, j);
4833 }
4834
4835 // Closure comparison
4836 BOOST_UBLAS_INLINE
4837 bool same_closure (const matrix_matrix_binary &mmb) const {
4838 return (*this).expression1 ().same_closure (mmb.expression1 ()) &&
4839 (*this).expression2 ().same_closure (mmb.expression2 ());
4840 }
4841
4842 // Iterator types
4843 private:
4844 typedef typename E1::const_iterator1 const_iterator11_type;
4845 typedef typename E1::const_iterator2 const_iterator12_type;
4846 typedef typename E2::const_iterator1 const_iterator21_type;
4847 typedef typename E2::const_iterator2 const_iterator22_type;
4848 typedef const value_type *const_pointer;
4849
4850 public:
4851#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4852 typedef typename iterator_restrict_traits<typename const_iterator11_type::iterator_category,
4853 typename const_iterator22_type::iterator_category>::iterator_category iterator_category;
4854 typedef indexed_const_iterator1<const_closure_type, iterator_category> const_iterator1;
4855 typedef const_iterator1 iterator1;
4856 typedef indexed_const_iterator2<const_closure_type, iterator_category> const_iterator2;
4857 typedef const_iterator2 iterator2;
4858#else
4859 class const_iterator1;
4860 typedef const_iterator1 iterator1;
4861 class const_iterator2;
4862 typedef const_iterator2 iterator2;
4863#endif
4864 typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
4865 typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
4866
4867 // Element lookup
4868 BOOST_UBLAS_INLINE
4869 const_iterator1 find1 (int /* rank */, size_type i, size_type j) const {
4870 // FIXME sparse matrix tests fail!
4871 // const_iterator11_type it11 (e1_.find1 (rank, i, 0));
4872 const_iterator11_type it11 (e1_.find1 (0, i, 0));
4873#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4874 return const_iterator1 (*this, it11.index1 (), j);
4875#else
4876 // FIXME sparse matrix tests fail!
4877 // const_iterator22_type it22 (e2_.find2 (rank, 0, j));
4878 const_iterator22_type it22 (e2_.find2 (0, 0, j));
4879 return const_iterator1 (*this, it11, it22);
4880#endif
4881 }
4882 BOOST_UBLAS_INLINE
4883 const_iterator2 find2 (int /* rank */, size_type i, size_type j) const {
4884 // FIXME sparse matrix tests fail!
4885 // const_iterator22_type it22 (e2_.find2 (rank, 0, j));
4886 const_iterator22_type it22 (e2_.find2 (0, 0, j));
4887#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
4888 return const_iterator2 (*this, i, it22.index2 ());
4889#else
4890 // FIXME sparse matrix tests fail!
4891 // const_iterator11_type it11 (e1_.find1 (rank, i, 0));
4892 const_iterator11_type it11 (e1_.find1 (0, i, 0));
4893 return const_iterator2 (*this, it11, it22);
4894#endif
4895 }
4896
4897
4898#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
4899 class const_iterator1:
4900 public container_const_reference<matrix_matrix_binary>,
4901 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
4902 typename E2::const_iterator2::iterator_category>::iterator_category>::template
4903 iterator_base<const_iterator1, value_type>::type {
4904 public:
4905 typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
4906 typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
4907 typedef typename matrix_matrix_binary::difference_type difference_type;
4908 typedef typename matrix_matrix_binary::value_type value_type;
4909 typedef typename matrix_matrix_binary::const_reference reference;
4910 typedef typename matrix_matrix_binary::const_pointer pointer;
4911
4912 typedef const_iterator2 dual_iterator_type;
4913 typedef const_reverse_iterator2 dual_reverse_iterator_type;
4914
4915 // Construction and destruction
4916#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4917 BOOST_UBLAS_INLINE
4918 const_iterator1 ():
4919 container_const_reference<self_type> (), it1_ (), it2_ (), it2_begin_ (), it2_end_ () {}
4920 BOOST_UBLAS_INLINE
4921 const_iterator1 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2):
4922 container_const_reference<self_type> (mmb), it1_ (it1), it2_ (it2), it2_begin_ (it2.begin ()), it2_end_ (it2.end ()) {}
4923#else
4924 BOOST_UBLAS_INLINE
4925 const_iterator1 ():
4926 container_const_reference<self_type> (), it1_ (), it2_ () {}
4927 BOOST_UBLAS_INLINE
4928 const_iterator1 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2):
4929 container_const_reference<self_type> (mmb), it1_ (it1), it2_ (it2) {}
4930#endif
4931
4932 private:
4933 // Random access specialization
4934 BOOST_UBLAS_INLINE
4935 value_type dereference (dense_random_access_iterator_tag) const {
4936 const self_type &mmb = (*this) ();
4937#ifdef BOOST_UBLAS_USE_INDEXING
4938 return mmb (index1 (), index2 ());
4939#elif BOOST_UBLAS_USE_ITERATING
4940 difference_type size = BOOST_UBLAS_SAME (mmb.expression1 ().size2 (), mmb.expression2 ().size1 ());
4941#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4942 return functor_type::apply (size, it1_.begin (), it2_begin_);
4943#else
4944 return functor_type::apply (size, it1_.begin (), it2_.begin ());
4945#endif
4946#else
4947 difference_type size = BOOST_UBLAS_SAME (mmb.expression1 ().size2 (), mmb.expression2 ().size1 ());
4948 if (size >= BOOST_UBLAS_ITERATOR_THRESHOLD)
4949#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4950 return functor_type::apply (size, it1_.begin (), it2_begin_);
4951#else
4952 return functor_type::apply (size, it1_.begin (), it2_.begin ());
4953#endif
4954 else
4955 return mmb (index1 (), index2 ());
4956#endif
4957 }
4958
4959 // Packed bidirectional specialization
4960 BOOST_UBLAS_INLINE
4961 value_type dereference (packed_random_access_iterator_tag) const {
4962#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4963 return functor_type::apply (it1_.begin (), it1_.end (),
4964 it2_begin_, it2_end_, packed_random_access_iterator_tag ());
4965#else
4966#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
4967 return functor_type::apply (it1_.begin (), it1_.end (),
4968 it2_.begin (), it2_.end (), packed_random_access_iterator_tag ());
4969#else
4970 return functor_type::apply (boost::numeric::ublas::begin (it1_, iterator1_tag ()),
4971 boost::numeric::ublas::end (it1_, iterator1_tag ()),
4972 boost::numeric::ublas::begin (it2_, iterator2_tag ()),
4973 boost::numeric::ublas::end (it2_, iterator2_tag ()), packed_random_access_iterator_tag ());
4974#endif
4975#endif
4976 }
4977
4978 // Sparse bidirectional specialization
4979 BOOST_UBLAS_INLINE
4980 value_type dereference (sparse_bidirectional_iterator_tag) const {
4981#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
4982 return functor_type::apply (it1_.begin (), it1_.end (),
4983 it2_begin_, it2_end_, sparse_bidirectional_iterator_tag ());
4984#else
4985#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
4986 return functor_type::apply (it1_.begin (), it1_.end (),
4987 it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());
4988#else
4989 return functor_type::apply (boost::numeric::ublas::begin (it1_, iterator1_tag ()),
4990 boost::numeric::ublas::end (it1_, iterator1_tag ()),
4991 boost::numeric::ublas::begin (it2_, iterator2_tag ()),
4992 boost::numeric::ublas::end (it2_, iterator2_tag ()), sparse_bidirectional_iterator_tag ());
4993#endif
4994#endif
4995 }
4996
4997 public:
4998 // Arithmetic
4999 BOOST_UBLAS_INLINE
5000 const_iterator1 &operator ++ () {
5001 ++ it1_;
5002 return *this;
5003 }
5004 BOOST_UBLAS_INLINE
5005 const_iterator1 &operator -- () {
5006 -- it1_;
5007 return *this;
5008 }
5009 BOOST_UBLAS_INLINE
5010 const_iterator1 &operator += (difference_type n) {
5011 it1_ += n;
5012 return *this;
5013 }
5014 BOOST_UBLAS_INLINE
5015 const_iterator1 &operator -= (difference_type n) {
5016 it1_ -= n;
5017 return *this;
5018 }
5019 BOOST_UBLAS_INLINE
5020 difference_type operator - (const const_iterator1 &it) const {
5021 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
5022 BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
5023 return it1_ - it.it1_;
5024 }
5025
5026 // Dereference
5027 BOOST_UBLAS_INLINE
5028 const_reference operator * () const {
5029 return dereference (iterator_category ());
5030 }
5031 BOOST_UBLAS_INLINE
5032 const_reference operator [] (difference_type n) const {
5033 return *(*this + n);
5034 }
5035
5036#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
5037 BOOST_UBLAS_INLINE
5038#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5039 typename self_type::
5040#endif
5041 const_iterator2 begin () const {
5042 return (*this) ().find2 (1, index1 (), 0);
5043 }
5044 BOOST_UBLAS_INLINE
5045#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5046 typename self_type::
5047#endif
5048 const_iterator2 cbegin () const {
5049 return begin ();
5050 }
5051 BOOST_UBLAS_INLINE
5052#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5053 typename self_type::
5054#endif
5055 const_iterator2 end () const {
5056 return (*this) ().find2 (1, index1 (), (*this) ().size2 ());
5057 }
5058 BOOST_UBLAS_INLINE
5059#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5060 typename self_type::
5061#endif
5062 const_iterator2 cend () const {
5063 return end ();
5064 }
5065 BOOST_UBLAS_INLINE
5066#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5067 typename self_type::
5068#endif
5069 const_reverse_iterator2 rbegin () const {
5070 return const_reverse_iterator2 (end ());
5071 }
5072 BOOST_UBLAS_INLINE
5073#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5074 typename self_type::
5075#endif
5076 const_reverse_iterator2 crbegin () const {
5077 return rbegin ();
5078 }
5079 BOOST_UBLAS_INLINE
5080#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5081 typename self_type::
5082#endif
5083 const_reverse_iterator2 rend () const {
5084 return const_reverse_iterator2 (begin ());
5085 }
5086 BOOST_UBLAS_INLINE
5087#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5088 typename self_type::
5089#endif
5090 const_reverse_iterator2 crend () const {
5091 return rend ();
5092 }
5093#endif
5094
5095 // Indices
5096 BOOST_UBLAS_INLINE
5097 size_type index1 () const {
5098 return it1_.index1 ();
5099 }
5100 BOOST_UBLAS_INLINE
5101 size_type index2 () const {
5102 return it2_.index2 ();
5103 }
5104
5105 // Assignment
5106 BOOST_UBLAS_INLINE
5107 const_iterator1 &operator = (const const_iterator1 &it) {
5108 container_const_reference<self_type>::assign (&it ());
5109 it1_ = it.it1_;
5110 it2_ = it.it2_;
5111#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5112 it2_begin_ = it.it2_begin_;
5113 it2_end_ = it.it2_end_;
5114#endif
5115 return *this;
5116 }
5117
5118 // Comparison
5119 BOOST_UBLAS_INLINE
5120 bool operator == (const const_iterator1 &it) const {
5121 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
5122 BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
5123 return it1_ == it.it1_;
5124 }
5125 BOOST_UBLAS_INLINE
5126 bool operator < (const const_iterator1 &it) const {
5127 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
5128 BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
5129 return it1_ < it.it1_;
5130 }
5131
5132 private:
5133 const_iterator11_type it1_;
5134 // Mutable due to assignment
5135 /* const */ const_iterator22_type it2_;
5136#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5137 /* const */ const_iterator21_type it2_begin_;
5138 /* const */ const_iterator21_type it2_end_;
5139#endif
5140 };
5141#endif
5142
5143 BOOST_UBLAS_INLINE
5144 const_iterator1 begin1 () const {
5145 return find1 (0, 0, 0);
5146 }
5147 BOOST_UBLAS_INLINE
5148 const_iterator1 cbegin1 () const {
5149 return begin1 ();
5150 }
5151 BOOST_UBLAS_INLINE
5152 const_iterator1 end1 () const {
5153 return find1 (0, size1 (), 0);
5154 }
5155 BOOST_UBLAS_INLINE
5156 const_iterator1 cend1 () const {
5157 return end1 ();
5158 }
5159
5160#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
5161 class const_iterator2:
5162 public container_const_reference<matrix_matrix_binary>,
5163 public iterator_base_traits<typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
5164 typename E2::const_iterator2::iterator_category>::iterator_category>::template
5165 iterator_base<const_iterator2, value_type>::type {
5166 public:
5167 typedef typename iterator_restrict_traits<typename E1::const_iterator1::iterator_category,
5168 typename E2::const_iterator2::iterator_category>::iterator_category iterator_category;
5169 typedef typename matrix_matrix_binary::difference_type difference_type;
5170 typedef typename matrix_matrix_binary::value_type value_type;
5171 typedef typename matrix_matrix_binary::const_reference reference;
5172 typedef typename matrix_matrix_binary::const_pointer pointer;
5173
5174 typedef const_iterator1 dual_iterator_type;
5175 typedef const_reverse_iterator1 dual_reverse_iterator_type;
5176
5177 // Construction and destruction
5178#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5179 BOOST_UBLAS_INLINE
5180 const_iterator2 ():
5181 container_const_reference<self_type> (), it1_ (), it2_ (), it1_begin_ (), it1_end_ () {}
5182 BOOST_UBLAS_INLINE
5183 const_iterator2 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2):
5184 container_const_reference<self_type> (mmb), it1_ (it1), it2_ (it2), it1_begin_ (it1.begin ()), it1_end_ (it1.end ()) {}
5185#else
5186 BOOST_UBLAS_INLINE
5187 const_iterator2 ():
5188 container_const_reference<self_type> (), it1_ (), it2_ () {}
5189 BOOST_UBLAS_INLINE
5190 const_iterator2 (const self_type &mmb, const const_iterator11_type &it1, const const_iterator22_type &it2):
5191 container_const_reference<self_type> (mmb), it1_ (it1), it2_ (it2) {}
5192#endif
5193
5194 private:
5195 // Random access specialization
5196 BOOST_UBLAS_INLINE
5197 value_type dereference (dense_random_access_iterator_tag) const {
5198 const self_type &mmb = (*this) ();
5199#ifdef BOOST_UBLAS_USE_INDEXING
5200 return mmb (index1 (), index2 ());
5201#elif BOOST_UBLAS_USE_ITERATING
5202 difference_type size = BOOST_UBLAS_SAME (mmb.expression1 ().size2 (), mmb.expression2 ().size1 ());
5203#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5204 return functor_type::apply (size, it1_begin_, it2_.begin ());
5205#else
5206 return functor_type::apply (size, it1_.begin (), it2_.begin ());
5207#endif
5208#else
5209 difference_type size = BOOST_UBLAS_SAME (mmb.expression1 ().size2 (), mmb.expression2 ().size1 ());
5210 if (size >= BOOST_UBLAS_ITERATOR_THRESHOLD)
5211#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5212 return functor_type::apply (size, it1_begin_, it2_.begin ());
5213#else
5214 return functor_type::apply (size, it1_.begin (), it2_.begin ());
5215#endif
5216 else
5217 return mmb (index1 (), index2 ());
5218#endif
5219 }
5220
5221 // Packed bidirectional specialization
5222 BOOST_UBLAS_INLINE
5223 value_type dereference (packed_random_access_iterator_tag) const {
5224#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5225 return functor_type::apply (it1_begin_, it1_end_,
5226 it2_.begin (), it2_.end (), packed_random_access_iterator_tag ());
5227#else
5228#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
5229 return functor_type::apply (it1_.begin (), it1_.end (),
5230 it2_.begin (), it2_.end (), packed_random_access_iterator_tag ());
5231#else
5232 return functor_type::apply (boost::numeric::ublas::begin (it1_, iterator1_tag ()),
5233 boost::numeric::ublas::end (it1_, iterator1_tag ()),
5234 boost::numeric::ublas::begin (it2_, iterator2_tag ()),
5235 boost::numeric::ublas::end (it2_, iterator2_tag ()), packed_random_access_iterator_tag ());
5236#endif
5237#endif
5238 }
5239
5240 // Sparse bidirectional specialization
5241 BOOST_UBLAS_INLINE
5242 value_type dereference (sparse_bidirectional_iterator_tag) const {
5243#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5244 return functor_type::apply (it1_begin_, it1_end_,
5245 it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());
5246#else
5247#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
5248 return functor_type::apply (it1_.begin (), it1_.end (),
5249 it2_.begin (), it2_.end (), sparse_bidirectional_iterator_tag ());
5250#else
5251 return functor_type::apply (boost::numeric::ublas::begin (it1_, iterator1_tag ()),
5252 boost::numeric::ublas::end (it1_, iterator1_tag ()),
5253 boost::numeric::ublas::begin (it2_, iterator2_tag ()),
5254 boost::numeric::ublas::end (it2_, iterator2_tag ()), sparse_bidirectional_iterator_tag ());
5255#endif
5256#endif
5257 }
5258
5259 public:
5260 // Arithmetic
5261 BOOST_UBLAS_INLINE
5262 const_iterator2 &operator ++ () {
5263 ++ it2_;
5264 return *this;
5265 }
5266 BOOST_UBLAS_INLINE
5267 const_iterator2 &operator -- () {
5268 -- it2_;
5269 return *this;
5270 }
5271 BOOST_UBLAS_INLINE
5272 const_iterator2 &operator += (difference_type n) {
5273 it2_ += n;
5274 return *this;
5275 }
5276 BOOST_UBLAS_INLINE
5277 const_iterator2 &operator -= (difference_type n) {
5278 it2_ -= n;
5279 return *this;
5280 }
5281 BOOST_UBLAS_INLINE
5282 difference_type operator - (const const_iterator2 &it) const {
5283 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
5284 BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
5285 return it2_ - it.it2_;
5286 }
5287
5288 // Dereference
5289 BOOST_UBLAS_INLINE
5290 const_reference operator * () const {
5291 return dereference (iterator_category ());
5292 }
5293 BOOST_UBLAS_INLINE
5294 const_reference operator [] (difference_type n) const {
5295 return *(*this + n);
5296 }
5297
5298#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
5299 BOOST_UBLAS_INLINE
5300#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5301 typename self_type::
5302#endif
5303 const_iterator1 begin () const {
5304 return (*this) ().find1 (1, 0, index2 ());
5305 }
5306 BOOST_UBLAS_INLINE
5307#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5308 typename self_type::
5309#endif
5310 const_iterator1 cbegin () const {
5311 return begin ();
5312 }
5313 BOOST_UBLAS_INLINE
5314#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5315 typename self_type::
5316#endif
5317 const_iterator1 end () const {
5318 return (*this) ().find1 (1, (*this) ().size1 (), index2 ());
5319 }
5320 BOOST_UBLAS_INLINE
5321#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5322 typename self_type::
5323#endif
5324 const_iterator1 cend () const {
5325 return end ();
5326 }
5327 BOOST_UBLAS_INLINE
5328#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5329 typename self_type::
5330#endif
5331 const_reverse_iterator1 rbegin () const {
5332 return const_reverse_iterator1 (end ());
5333 }
5334 BOOST_UBLAS_INLINE
5335#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5336 typename self_type::
5337#endif
5338 const_reverse_iterator1 crbegin () const {
5339 return rbegin ();
5340 }
5341 BOOST_UBLAS_INLINE
5342#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5343 typename self_type::
5344#endif
5345 const_reverse_iterator1 rend () const {
5346 return const_reverse_iterator1 (begin ());
5347 }
5348 BOOST_UBLAS_INLINE
5349#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
5350 typename self_type::
5351#endif
5352 const_reverse_iterator1 crend () const {
5353 return rend ();
5354 }
5355#endif
5356
5357 // Indices
5358 BOOST_UBLAS_INLINE
5359 size_type index1 () const {
5360 return it1_.index1 ();
5361 }
5362 BOOST_UBLAS_INLINE
5363 size_type index2 () const {
5364 return it2_.index2 ();
5365 }
5366
5367 // Assignment
5368 BOOST_UBLAS_INLINE
5369 const_iterator2 &operator = (const const_iterator2 &it) {
5370 container_const_reference<self_type>::assign (&it ());
5371 it1_ = it.it1_;
5372 it2_ = it.it2_;
5373#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5374 it1_begin_ = it.it1_begin_;
5375 it1_end_ = it.it1_end_;
5376#endif
5377 return *this;
5378 }
5379
5380 // Comparison
5381 BOOST_UBLAS_INLINE
5382 bool operator == (const const_iterator2 &it) const {
5383 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
5384 BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
5385 return it2_ == it.it2_;
5386 }
5387 BOOST_UBLAS_INLINE
5388 bool operator < (const const_iterator2 &it) const {
5389 BOOST_UBLAS_CHECK ((*this) ().same_closure (it ()), external_logic ());
5390 BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
5391 return it2_ < it.it2_;
5392 }
5393
5394 private:
5395 // Mutable due to assignment
5396 /* const */ const_iterator11_type it1_;
5397 const_iterator22_type it2_;
5398#ifdef BOOST_UBLAS_USE_INVARIANT_HOISTING
5399 /* const */ const_iterator12_type it1_begin_;
5400 /* const */ const_iterator12_type it1_end_;
5401#endif
5402 };
5403#endif
5404
5405 BOOST_UBLAS_INLINE
5406 const_iterator2 begin2 () const {
5407 return find2 (0, 0, 0);
5408 }
5409 BOOST_UBLAS_INLINE
5410 const_iterator2 cbegin2 () const {
5411 return begin2 ();
5412 }
5413 BOOST_UBLAS_INLINE
5414 const_iterator2 end2 () const {
5415 return find2 (0, 0, size2 ());
5416 }
5417 BOOST_UBLAS_INLINE
5418 const_iterator2 cend2 () const {
5419 return end2 ();
5420 }
5421
5422 // Reverse iterators
5423
5424 BOOST_UBLAS_INLINE
5425 const_reverse_iterator1 rbegin1 () const {
5426 return const_reverse_iterator1 (end1 ());
5427 }
5428 BOOST_UBLAS_INLINE
5429 const_reverse_iterator1 crbegin1 () const {
5430 return rbegin1 ();
5431 }
5432 BOOST_UBLAS_INLINE
5433 const_reverse_iterator1 rend1 () const {
5434 return const_reverse_iterator1 (begin1 ());
5435 }
5436 BOOST_UBLAS_INLINE
5437 const_reverse_iterator1 crend1 () const {
5438 return rend1 ();
5439 }
5440
5441 BOOST_UBLAS_INLINE
5442 const_reverse_iterator2 rbegin2 () const {
5443 return const_reverse_iterator2 (end2 ());
5444 }
5445 BOOST_UBLAS_INLINE
5446 const_reverse_iterator2 crbegin2 () const {
5447 return rbegin2 ();
5448 }
5449 BOOST_UBLAS_INLINE
5450 const_reverse_iterator2 rend2 () const {
5451 return const_reverse_iterator2 (begin2 ());
5452 }
5453 BOOST_UBLAS_INLINE
5454 const_reverse_iterator2 crend2 () const {
5455 return rend2 ();
5456 }
5457
5458 private:
5459 expression1_closure_type e1_;
5460 expression2_closure_type e2_;
5461 };
5462
5463 template<class T1, class E1, class T2, class E2>
5464 struct matrix_matrix_binary_traits {
5465 typedef unknown_storage_tag storage_category;
5466 typedef unknown_orientation_tag orientation_category;
5467 typedef typename promote_traits<T1, T2>::promote_type promote_type;
5468 typedef matrix_matrix_binary<E1, E2, matrix_matrix_prod<E1, E2, promote_type> > expression_type;
5469#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
5470 typedef expression_type result_type;
5471#else
5472 typedef typename E1::matrix_temporary_type result_type;
5473#endif
5474 };
5475
5476 template<class E1, class E2>
5477 BOOST_UBLAS_INLINE
5478 typename matrix_matrix_binary_traits<typename E1::value_type, E1,
5479 typename E2::value_type, E2>::result_type
5480 prod (const matrix_expression<E1> &e1,
5481 const matrix_expression<E2> &e2,
5482 unknown_storage_tag,
5483 unknown_orientation_tag) {
5484 typedef typename matrix_matrix_binary_traits<typename E1::value_type, E1,
5485 typename E2::value_type, E2>::expression_type expression_type;
5486 return expression_type (e1 (), e2 ());
5487 }
5488
5489 // Dispatcher
5490 template<class E1, class E2>
5491 BOOST_UBLAS_INLINE
5492 typename matrix_matrix_binary_traits<typename E1::value_type, E1,
5493 typename E2::value_type, E2>::result_type
5494 prod (const matrix_expression<E1> &e1,
5495 const matrix_expression<E2> &e2) {
5496 BOOST_STATIC_ASSERT (E1::complexity == 0 && E2::complexity == 0);
5497 typedef typename matrix_matrix_binary_traits<typename E1::value_type, E1,
5498 typename E2::value_type, E2>::storage_category storage_category;
5499 typedef typename matrix_matrix_binary_traits<typename E1::value_type, E1,
5500 typename E2::value_type, E2>::orientation_category orientation_category;
5501 return prod (e1, e2, storage_category (), orientation_category ());
5502 }
5503
5504 template<class E1, class E2>
5505 BOOST_UBLAS_INLINE
5506 typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
5507 typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
5508 prec_prod (const matrix_expression<E1> &e1,
5509 const matrix_expression<E2> &e2,
5510 unknown_storage_tag,
5511 unknown_orientation_tag) {
5512 typedef typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
5513 typename type_traits<typename E2::value_type>::precision_type, E2>::expression_type expression_type;
5514 return expression_type (e1 (), e2 ());
5515 }
5516
5517 // Dispatcher
5518 template<class E1, class E2>
5519 BOOST_UBLAS_INLINE
5520 typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
5521 typename type_traits<typename E2::value_type>::precision_type, E2>::result_type
5522 prec_prod (const matrix_expression<E1> &e1,
5523 const matrix_expression<E2> &e2) {
5524 BOOST_STATIC_ASSERT (E1::complexity == 0 && E2::complexity == 0);
5525 typedef typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
5526 typename type_traits<typename E2::value_type>::precision_type, E2>::storage_category storage_category;
5527 typedef typename matrix_matrix_binary_traits<typename type_traits<typename E1::value_type>::precision_type, E1,
5528 typename type_traits<typename E2::value_type>::precision_type, E2>::orientation_category orientation_category;
5529 return prec_prod (e1, e2, storage_category (), orientation_category ());
5530 }
5531
5532 template<class M, class E1, class E2>
5533 BOOST_UBLAS_INLINE
5534 M &
5535 prod (const matrix_expression<E1> &e1,
5536 const matrix_expression<E2> &e2,
5537 M &m) {
5538 return m.assign (prod (e1, e2));
5539 }
5540
5541 template<class M, class E1, class E2>
5542 BOOST_UBLAS_INLINE
5543 M &
5544 prec_prod (const matrix_expression<E1> &e1,
5545 const matrix_expression<E2> &e2,
5546 M &m) {
5547 return m.assign (prec_prod (e1, e2));
5548 }
5549
5550 template<class M, class E1, class E2>
5551 BOOST_UBLAS_INLINE
5552 M
5553 prod (const matrix_expression<E1> &e1,
5554 const matrix_expression<E2> &e2) {
5555 return M (prod (e1, e2));
5556 }
5557
5558 template<class M, class E1, class E2>
5559 BOOST_UBLAS_INLINE
5560 M
5561 prec_prod (const matrix_expression<E1> &e1,
5562 const matrix_expression<E2> &e2) {
5563 return M (prec_prod (e1, e2));
5564 }
5565
5566 template<class E, class F>
5567 class matrix_scalar_unary:
5568 public scalar_expression<matrix_scalar_unary<E, F> > {
5569 public:
5570 typedef E expression_type;
5571 typedef F functor_type;
5572 typedef typename F::result_type value_type;
5573 typedef typename E::const_closure_type expression_closure_type;
5574
5575 // Construction and destruction
5576 BOOST_UBLAS_INLINE
5577 explicit matrix_scalar_unary (const expression_type &e):
5578 e_ (e) {}
5579
5580 private:
5581 // Expression accessors
5582 BOOST_UBLAS_INLINE
5583 const expression_closure_type &expression () const {
5584 return e_;
5585 }
5586
5587 public:
5588 BOOST_UBLAS_INLINE
5589 operator value_type () const {
5590 return functor_type::apply (e_);
5591 }
5592
5593 private:
5594 expression_closure_type e_;
5595 };
5596
5597 template<class E, class F>
5598 struct matrix_scalar_unary_traits {
5599 typedef matrix_scalar_unary<E, F> expression_type;
5600#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
5601 typedef expression_type result_type;
5602#else
5603 typedef typename F::result_type result_type;
5604#endif
5605 };
5606
5607 template<class E>
5608 BOOST_UBLAS_INLINE
5609 typename matrix_scalar_unary_traits<E, matrix_norm_1<E> >::result_type
5610 norm_1 (const matrix_expression<E> &e) {
5611 typedef typename matrix_scalar_unary_traits<E, matrix_norm_1<E> >::expression_type expression_type;
5612 return expression_type (e ());
5613 }
5614
5615 template<class E>
5616 BOOST_UBLAS_INLINE
5617 typename matrix_scalar_unary_traits<E, matrix_norm_frobenius<E> >::result_type
5618 norm_frobenius (const matrix_expression<E> &e) {
5619 typedef typename matrix_scalar_unary_traits<E, matrix_norm_frobenius<E> >::expression_type expression_type;
5620 return expression_type (e ());
5621 }
5622
5623 template<class E>
5624 BOOST_UBLAS_INLINE
5625 typename matrix_scalar_unary_traits<E, matrix_norm_inf<E> >::result_type
5626 norm_inf (const matrix_expression<E> &e) {
5627 typedef typename matrix_scalar_unary_traits<E, matrix_norm_inf<E> >::expression_type expression_type;
5628 return expression_type (e ());
5629 }
5630
5631}}}
5632
5633#endif