Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

banded.hpp @ 857

Revision 857, 72.2 KB checked in by igarcia, 18 years ago (diff)

Line
1	//
2	// Copyright (c) 2000-2002
3	// Joerg Walter, Mathias Koch
4	//
5	// Permission to use, copy, modify, distribute and sell this software
6	// and its documentation for any purpose is hereby granted without fee,
7	// provided that the above copyright notice appear in all copies and
8	// that both that copyright notice and this permission notice appear
9	// in supporting documentation. The authors make no representations
10	// about the suitability of this software for any purpose.
11	// It is provided "as is" without express or implied warranty.
12	//
13	// The authors gratefully acknowledge the support of
14	// GeNeSys mbH & Co. KG in producing this work.
15	//
16
17	#ifndef _BOOST_UBLAS_BANDED_
18	#define _BOOST_UBLAS_BANDED_
19
20	#include <boost/numeric/ublas/matrix.hpp>
21	#include <boost/numeric/ublas/detail/temporary.hpp>
22
23	// Iterators based on ideas of Jeremy Siek
24
25	namespace boost { namespace numeric { namespace ublas {
26
27	// Array based banded matrix class
28	template<class T, class L, class A>
29	class banded_matrix:
30	public matrix_container<banded_matrix<T, L, A> > {
31
32	typedef T *pointer;
33	typedef L layout_type;
34	typedef banded_matrix<T, L, A> self_type;
35	public:
36	#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
37	using matrix_container<self_type>::operator ();
38	#endif
39	typedef typename A::size_type size_type;
40	typedef typename A::difference_type difference_type;
41	typedef T value_type;
42	typedef const T &const_reference;
43	typedef T &reference;
44	typedef A array_type;
45	typedef const matrix_reference<const self_type> const_closure_type;
46	typedef matrix_reference<self_type> closure_type;
47	typedef vector<T, A> vector_temporary_type;
48	typedef matrix<T, L, A> matrix_temporary_type; // general sub-matrix
49	typedef packed_tag storage_category;
50	typedef typename L::orientation_category orientation_category;
51
52	// Construction and destruction
53	BOOST_UBLAS_INLINE
54	banded_matrix ():
55	matrix_container<self_type> (),
56	size1_ (0), size2_ (0),
57	lower_ (0), upper_ (0), data_ (0) {}
58	BOOST_UBLAS_INLINE
59	banded_matrix (size_type size1, size_type size2, size_type lower = 0, size_type upper = 0):
60	matrix_container<self_type> (),
61	size1_ (size1), size2_ (size2),
62	lower_ (lower), upper_ (upper), data_ ((std::max) (size1, size2) * (lower + 1 + upper)) {
63	}
64	BOOST_UBLAS_INLINE
65	banded_matrix (size_type size1, size_type size2, size_type lower, size_type upper, const array_type &data):
66	matrix_container<self_type> (),
67	size1_ (size1), size2_ (size2),
68	lower_ (lower), upper_ (upper), data_ (data) {}
69	BOOST_UBLAS_INLINE
70	banded_matrix (const banded_matrix &m):
71	matrix_container<self_type> (),
72	size1_ (m.size1_), size2_ (m.size2_),
73	lower_ (m.lower_), upper_ (m.upper_), data_ (m.data_) {}
74	template<class AE>
75	BOOST_UBLAS_INLINE
76	banded_matrix (const matrix_expression<AE> &ae, size_type lower = 0, size_type upper = 0):
77	matrix_container<self_type> (),
78	size1_ (ae ().size1 ()), size2_ (ae ().size2 ()),
79	lower_ (lower), upper_ (upper),
80	data_ ((std::max) (size1_, size2_) * (lower_ + 1 + upper_)) {
81	matrix_assign<scalar_assign> (*this, ae);
82	}
83
84	// Accessors
85	BOOST_UBLAS_INLINE
86	size_type size1 () const {
87	return size1_;
88	}
89	BOOST_UBLAS_INLINE
90	size_type size2 () const {
91	return size2_;
92	}
93	BOOST_UBLAS_INLINE
94	size_type lower () const {
95	return lower_;
96	}
97	BOOST_UBLAS_INLINE
98	size_type upper () const {
99	return upper_;
100	}
101
102	// Storage accessors
103	BOOST_UBLAS_INLINE
104	const array_type &data () const {
105	return data_;
106	}
107	BOOST_UBLAS_INLINE
108	array_type &data () {
109	return data_;
110	}
111
112	// Resizing
113	BOOST_UBLAS_INLINE
114	void resize (size_type size1, size_type size2, size_type lower = 0, size_type upper = 0, bool preserve = true) {
115	if (preserve) {
116	self_type temporary (size1, size2, lower, upper);
117	detail::matrix_resize_preserve<layout_type> (*this, temporary);
118	}
119	else {
120	data ().resize ((std::max) (size1, size2) * (lower + 1 + upper));
121	size1_ = size1;
122	size2_ = size2;
123	lower_ = lower;
124	upper_ = upper;
125	}
126	}
127
128	BOOST_UBLAS_INLINE
129	void resize_packed_preserve (size_type size1, size_type size2, size_type lower = 0, size_type upper = 0) {
130	size1_ = size1;
131	size2_ = size2;
132	lower_ = lower;
133	upper_ = upper;
134	data ().resize ((std::max) (size1, size2) * (lower + 1 + upper), value_type ());
135	}
136
137	// Element access
138	BOOST_UBLAS_INLINE
139	const_reference operator () (size_type i, size_type j) const {
140	BOOST_UBLAS_CHECK (i < size1_, bad_index ());
141	BOOST_UBLAS_CHECK (j < size2_, bad_index ());
142	#ifdef BOOST_UBLAS_OWN_BANDED
143	const size_type k = (std::max) (i, j);
144	const size_type l = lower_ + j - i;
145	if (k < (std::max) (size1_, size2_) &&
146	l < lower_ + 1 + upper_)
147	return data () [layout_type::element (k, (std::max) (size1_, size2_),
148	l, lower_ + 1 + upper_)];
149	#else
150	const size_type k = j;
151	const size_type l = upper_ + i - j;
152	if (k < size2_ &&
153	l < lower_ + 1 + upper_)
154	return data () [layout_type::element (k, size2_,
155	l, lower_ + 1 + upper_)];
156	#endif
157	return zero_;
158	}
159	BOOST_UBLAS_INLINE
160	reference at_element (size_type i, size_type j) {
161	BOOST_UBLAS_CHECK (i < size1_, bad_index ());
162	BOOST_UBLAS_CHECK (j < size2_, bad_index ());
163	#ifdef BOOST_UBLAS_OWN_BANDED
164	const size_type k = (std::max) (i, j);
165	const size_type l = lower_ + j - i;
166	return data () [layout_type::element (k, (std::max) (size1_, size2_),
167	l, lower_ + 1 + upper_)];
168	#else
169	const size_type k = j;
170	const size_type l = upper_ + i - j;
171	return data () [layout_type::element (k, size2_,
172	l, lower_ + 1 + upper_)];
173	#endif
174	}
175	BOOST_UBLAS_INLINE
176	reference operator () (size_type i, size_type j) {
177	BOOST_UBLAS_CHECK (i < size1_, bad_index ());
178	BOOST_UBLAS_CHECK (j < size2_, bad_index ());
179	#ifdef BOOST_UBLAS_OWN_BANDED
180	const size_type k = (std::max) (i, j);
181	const size_type l = lower_ + j - i;
182	if (k < (std::max) (size1_, size2_) &&
183	l < lower_ + 1 + upper_)
184	return data () [layout_type::element (k, (std::max) (size1_, size2_),
185	l, lower_ + 1 + upper_)];
186	#else
187	const size_type k = j;
188	const size_type l = upper_ + i - j;
189	if (k < size2_ &&
190	l < lower_ + 1 + upper_)
191	return data () [layout_type::element (k, size2_,
192	l, lower_ + 1 + upper_)];
193	#endif
194	bad_index ().raise ();
195	// arbitary return value
196	return const_cast<reference>(zero_);
197	}
198
199	// Element assignment
200	BOOST_UBLAS_INLINE
201	reference insert_element (size_type i, size_type j, const_reference t) {
202	return (operator () (i, j) = t);
203	}
204	BOOST_UBLAS_INLINE
205	void erase_element (size_type i, size_type j) {
206	operator () (i, j) = value_type/zero/();
207	}
208
209	// Zeroing
210	BOOST_UBLAS_INLINE
211	void clear () {
212	std::fill (data ().begin (), data ().end (), value_type/zero/());
213	}
214
215	// Assignment
216	BOOST_UBLAS_INLINE
217	banded_matrix &operator = (const banded_matrix &m) {
218	size1_ = m.size1_;
219	size2_ = m.size2_;
220	lower_ = m.lower_;
221	upper_ = m.upper_;
222	data () = m.data ();
223	return *this;
224	}
225	BOOST_UBLAS_INLINE
226	banded_matrix &assign_temporary (banded_matrix &m) {
227	swap (m);
228	return *this;
229	}
230	template<class AE>
231	BOOST_UBLAS_INLINE
232	banded_matrix &operator = (const matrix_expression<AE> &ae) {
233	self_type temporary (ae, lower_, upper_);
234	return assign_temporary (temporary);
235	}
236	template<class AE>
237	BOOST_UBLAS_INLINE
238	banded_matrix &assign (const matrix_expression<AE> &ae) {
239	matrix_assign<scalar_assign> (*this, ae);
240	return *this;
241	}
242	template<class AE>
243	BOOST_UBLAS_INLINE
244	banded_matrix& operator += (const matrix_expression<AE> &ae) {
245	self_type temporary (*this + ae, lower_, upper_);
246	return assign_temporary (temporary);
247	}
248	template<class AE>
249	BOOST_UBLAS_INLINE
250	banded_matrix &plus_assign (const matrix_expression<AE> &ae) {
251	matrix_assign<scalar_plus_assign> (*this, ae);
252	return *this;
253	}
254	template<class AE>
255	BOOST_UBLAS_INLINE
256	banded_matrix& operator -= (const matrix_expression<AE> &ae) {
257	self_type temporary (*this - ae, lower_, upper_);
258	return assign_temporary (temporary);
259	}
260	template<class AE>
261	BOOST_UBLAS_INLINE
262	banded_matrix &minus_assign (const matrix_expression<AE> &ae) {
263	matrix_assign<scalar_minus_assign> (*this, ae);
264	return *this;
265	}
266	template<class AT>
267	BOOST_UBLAS_INLINE
268	banded_matrix& operator *= (const AT &at) {
269	matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
270	return *this;
271	}
272	template<class AT>
273	BOOST_UBLAS_INLINE
274	banded_matrix& operator /= (const AT &at) {
275	matrix_assign_scalar<scalar_divides_assign> (*this, at);
276	return *this;
277	}
278
279	// Swapping
280	BOOST_UBLAS_INLINE
281	void swap (banded_matrix &m) {
282	if (this != &m) {
283	std::swap (size1_, m.size1_);
284	std::swap (size2_, m.size2_);
285	std::swap (lower_, m.lower_);
286	std::swap (upper_, m.upper_);
287	data ().swap (m.data ());
288	}
289	}
290	BOOST_UBLAS_INLINE
291	friend void swap (banded_matrix &m1, banded_matrix &m2) {
292	m1.swap (m2);
293	}
294
295	// Iterator types
296	#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
297	typedef indexed_iterator1<self_type, packed_random_access_iterator_tag> iterator1;
298	typedef indexed_iterator2<self_type, packed_random_access_iterator_tag> iterator2;
299	typedef indexed_const_iterator1<self_type, packed_random_access_iterator_tag> const_iterator1;
300	typedef indexed_const_iterator2<self_type, packed_random_access_iterator_tag> const_iterator2;
301	#else
302	class const_iterator1;
303	class iterator1;
304	class const_iterator2;
305	class iterator2;
306	#endif
307	typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
308	typedef reverse_iterator_base1<iterator1> reverse_iterator1;
309	typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
310	typedef reverse_iterator_base2<iterator2> reverse_iterator2;
311
312	// Element lookup
313	BOOST_UBLAS_INLINE
314	const_iterator1 find1 (int rank, size_type i, size_type j) const {
315	if (rank == 1) {
316	size_type lower_i = (std::max) (difference_type (j - upper_), difference_type (0));
317	i = (std::max) (i, lower_i);
318	size_type upper_i = (std::min) (j + 1 + lower_, size1_);
319	i = (std::min) (i, upper_i);
320	}
321	return const_iterator1 (*this, i, j);
322	}
323	BOOST_UBLAS_INLINE
324	iterator1 find1 (int rank, size_type i, size_type j) {
325	if (rank == 1) {
326	size_type lower_i = (std::max) (difference_type (j - upper_), difference_type (0));
327	i = (std::max) (i, lower_i);
328	size_type upper_i = (std::min) (j + 1 + lower_, size1_);
329	i = (std::min) (i, upper_i);
330	}
331	return iterator1 (*this, i, j);
332	}
333	BOOST_UBLAS_INLINE
334	const_iterator2 find2 (int rank, size_type i, size_type j) const {
335	if (rank == 1) {
336	size_type lower_j = (std::max) (difference_type (i - lower_), difference_type (0));
337	j = (std::max) (j, lower_j);
338	size_type upper_j = (std::min) (i + 1 + upper_, size2_);
339	j = (std::min) (j, upper_j);
340	}
341	return const_iterator2 (*this, i, j);
342	}
343	BOOST_UBLAS_INLINE
344	iterator2 find2 (int rank, size_type i, size_type j) {
345	if (rank == 1) {
346	size_type lower_j = (std::max) (difference_type (i - lower_), difference_type (0));
347	j = (std::max) (j, lower_j);
348	size_type upper_j = (std::min) (i + 1 + upper_, size2_);
349	j = (std::min) (j, upper_j);
350	}
351	return iterator2 (*this, i, j);
352	}
353
354	// Iterators simply are indices.
355
356	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
357	class const_iterator1:
358	public container_const_reference<banded_matrix>,
359	public random_access_iterator_base<packed_random_access_iterator_tag,
360	const_iterator1, value_type> {
361	public:
362	typedef typename banded_matrix::value_type value_type;
363	typedef typename banded_matrix::difference_type difference_type;
364	typedef typename banded_matrix::const_reference reference;
365	typedef const typename banded_matrix::pointer pointer;
366
367	typedef const_iterator2 dual_iterator_type;
368	typedef const_reverse_iterator2 dual_reverse_iterator_type;
369
370	// Construction and destruction
371	BOOST_UBLAS_INLINE
372	const_iterator1 ():
373	container_const_reference<self_type> (), it1_ (), it2_ () {}
374	BOOST_UBLAS_INLINE
375	const_iterator1 (const self_type &m, size_type it1, size_type it2):
376	container_const_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
377	BOOST_UBLAS_INLINE
378	const_iterator1 (const iterator1 &it):
379	container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}
380
381	// Arithmetic
382	BOOST_UBLAS_INLINE
383	const_iterator1 &operator ++ () {
384	++ it1_;
385	return *this;
386	}
387	BOOST_UBLAS_INLINE
388	const_iterator1 &operator -- () {
389	-- it1_;
390	return *this;
391	}
392	BOOST_UBLAS_INLINE
393	const_iterator1 &operator += (difference_type n) {
394	it1_ += n;
395	return *this;
396	}
397	BOOST_UBLAS_INLINE
398	const_iterator1 &operator -= (difference_type n) {
399	it1_ -= n;
400	return *this;
401	}
402	BOOST_UBLAS_INLINE
403	difference_type operator - (const const_iterator1 &it) const {
404	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
405	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
406	return it1_ - it.it1_;
407	}
408
409	// Dereference
410	BOOST_UBLAS_INLINE
411	const_reference operator * () const {
412	return (*this) () (it1_, it2_);
413	}
414
415	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
416	BOOST_UBLAS_INLINE
417	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
418	typename self_type::
419	#endif
420	const_iterator2 begin () const {
421	return (*this) ().find2 (1, it1_, 0);
422	}
423	BOOST_UBLAS_INLINE
424	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
425	typename self_type::
426	#endif
427	const_iterator2 end () const {
428	return (this) ().find2 (1, it1_, (this) ().size2 ());
429	}
430	BOOST_UBLAS_INLINE
431	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
432	typename self_type::
433	#endif
434	const_reverse_iterator2 rbegin () const {
435	return const_reverse_iterator2 (end ());
436	}
437	BOOST_UBLAS_INLINE
438	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
439	typename self_type::
440	#endif
441	const_reverse_iterator2 rend () const {
442	return const_reverse_iterator2 (begin ());
443	}
444	#endif
445
446	// Indices
447	BOOST_UBLAS_INLINE
448	size_type index1 () const {
449	return it1_;
450	}
451	BOOST_UBLAS_INLINE
452	size_type index2 () const {
453	return it2_;
454	}
455
456	// Assignment
457	BOOST_UBLAS_INLINE
458	const_iterator1 &operator = (const const_iterator1 &it) {
459	container_const_reference<self_type>::assign (&it ());
460	it1_ = it.it1_;
461	it2_ = it.it2_;
462	return *this;
463	}
464
465	// Comparison
466	BOOST_UBLAS_INLINE
467	bool operator == (const const_iterator1 &it) const {
468	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
469	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
470	return it1_ == it.it1_;
471	}
472	BOOST_UBLAS_INLINE
473	bool operator < (const const_iterator1 &it) const {
474	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
475	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
476	return it1_ < it.it1_;
477	}
478
479	private:
480	size_type it1_;
481	size_type it2_;
482	};
483	#endif
484
485	BOOST_UBLAS_INLINE
486	const_iterator1 begin1 () const {
487	return find1 (0, 0, 0);
488	}
489	BOOST_UBLAS_INLINE
490	const_iterator1 end1 () const {
491	return find1 (0, size1_, 0);
492	}
493
494	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
495	class iterator1:
496	public container_reference<banded_matrix>,
497	public random_access_iterator_base<packed_random_access_iterator_tag,
498	iterator1, value_type> {
499	public:
500	typedef typename banded_matrix::value_type value_type;
501	typedef typename banded_matrix::difference_type difference_type;
502	typedef typename banded_matrix::reference reference;
503	typedef typename banded_matrix::pointer pointer;
504
505	typedef iterator2 dual_iterator_type;
506	typedef reverse_iterator2 dual_reverse_iterator_type;
507
508	// Construction and destruction
509	BOOST_UBLAS_INLINE
510	iterator1 ():
511	container_reference<self_type> (), it1_ (), it2_ () {}
512	BOOST_UBLAS_INLINE
513	iterator1 (self_type &m, size_type it1, size_type it2):
514	container_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
515
516	// Arithmetic
517	BOOST_UBLAS_INLINE
518	iterator1 &operator ++ () {
519	++ it1_;
520	return *this;
521	}
522	BOOST_UBLAS_INLINE
523	iterator1 &operator -- () {
524	-- it1_;
525	return *this;
526	}
527	BOOST_UBLAS_INLINE
528	iterator1 &operator += (difference_type n) {
529	it1_ += n;
530	return *this;
531	}
532	BOOST_UBLAS_INLINE
533	iterator1 &operator -= (difference_type n) {
534	it1_ -= n;
535	return *this;
536	}
537	BOOST_UBLAS_INLINE
538	difference_type operator - (const iterator1 &it) const {
539	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
540	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
541	return it1_ - it.it1_;
542	}
543
544	// Dereference
545	BOOST_UBLAS_INLINE
546	reference operator * () const {
547	return (*this) ().at_element (it1_, it2_);
548	}
549
550	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
551	BOOST_UBLAS_INLINE
552	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
553	typename self_type::
554	#endif
555	iterator2 begin () const {
556	return (*this) ().find2 (1, it1_, 0);
557	}
558	BOOST_UBLAS_INLINE
559	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
560	typename self_type::
561	#endif
562	iterator2 end () const {
563	return (this) ().find2 (1, it1_, (this) ().size2 ());
564	}
565	BOOST_UBLAS_INLINE
566	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
567	typename self_type::
568	#endif
569	reverse_iterator2 rbegin () const {
570	return reverse_iterator2 (end ());
571	}
572	BOOST_UBLAS_INLINE
573	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
574	typename self_type::
575	#endif
576	reverse_iterator2 rend () const {
577	return reverse_iterator2 (begin ());
578	}
579	#endif
580
581	// Indices
582	BOOST_UBLAS_INLINE
583	size_type index1 () const {
584	return it1_;
585	}
586	BOOST_UBLAS_INLINE
587	size_type index2 () const {
588	return it2_;
589	}
590
591	// Assignment
592	BOOST_UBLAS_INLINE
593	iterator1 &operator = (const iterator1 &it) {
594	container_reference<self_type>::assign (&it ());
595	it1_ = it.it1_;
596	it2_ = it.it2_;
597	return *this;
598	}
599
600	// Comparison
601	BOOST_UBLAS_INLINE
602	bool operator == (const iterator1 &it) const {
603	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
604	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
605	return it1_ == it.it1_;
606	}
607	BOOST_UBLAS_INLINE
608	bool operator < (const iterator1 &it) const {
609	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
610	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
611	return it1_ < it.it1_;
612	}
613
614	private:
615	size_type it1_;
616	size_type it2_;
617
618	friend class const_iterator1;
619	};
620	#endif
621
622	BOOST_UBLAS_INLINE
623	iterator1 begin1 () {
624	return find1 (0, 0, 0);
625	}
626	BOOST_UBLAS_INLINE
627	iterator1 end1 () {
628	return find1 (0, size1_, 0);
629	}
630
631	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
632	class const_iterator2:
633	public container_const_reference<banded_matrix>,
634	public random_access_iterator_base<packed_random_access_iterator_tag,
635	const_iterator2, value_type> {
636	public:
637	typedef typename banded_matrix::value_type value_type;
638	typedef typename banded_matrix::difference_type difference_type;
639	typedef typename banded_matrix::const_reference reference;
640	typedef const typename banded_matrix::pointer pointer;
641
642	typedef const_iterator1 dual_iterator_type;
643	typedef const_reverse_iterator1 dual_reverse_iterator_type;
644
645	// Construction and destruction
646	BOOST_UBLAS_INLINE
647	const_iterator2 ():
648	container_const_reference<self_type> (), it1_ (), it2_ () {}
649	BOOST_UBLAS_INLINE
650	const_iterator2 (const self_type &m, size_type it1, size_type it2):
651	container_const_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
652	BOOST_UBLAS_INLINE
653	const_iterator2 (const iterator2 &it):
654	container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}
655
656	// Arithmetic
657	BOOST_UBLAS_INLINE
658	const_iterator2 &operator ++ () {
659	++ it2_;
660	return *this;
661	}
662	BOOST_UBLAS_INLINE
663	const_iterator2 &operator -- () {
664	-- it2_;
665	return *this;
666	}
667	BOOST_UBLAS_INLINE
668	const_iterator2 &operator += (difference_type n) {
669	it2_ += n;
670	return *this;
671	}
672	BOOST_UBLAS_INLINE
673	const_iterator2 &operator -= (difference_type n) {
674	it2_ -= n;
675	return *this;
676	}
677	BOOST_UBLAS_INLINE
678	difference_type operator - (const const_iterator2 &it) const {
679	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
680	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
681	return it2_ - it.it2_;
682	}
683
684	// Dereference
685	BOOST_UBLAS_INLINE
686	const_reference operator * () const {
687	return (*this) () (it1_, it2_);
688	}
689
690	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
691	BOOST_UBLAS_INLINE
692	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
693	typename self_type::
694	#endif
695	const_iterator1 begin () const {
696	return (*this) ().find1 (1, 0, it2_);
697	}
698	BOOST_UBLAS_INLINE
699	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
700	typename self_type::
701	#endif
702	const_iterator1 end () const {
703	return (this) ().find1 (1, (this) ().size1 (), it2_);
704	}
705	BOOST_UBLAS_INLINE
706	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
707	typename self_type::
708	#endif
709	const_reverse_iterator1 rbegin () const {
710	return const_reverse_iterator1 (end ());
711	}
712	BOOST_UBLAS_INLINE
713	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
714	typename self_type::
715	#endif
716	const_reverse_iterator1 rend () const {
717	return const_reverse_iterator1 (begin ());
718	}
719	#endif
720
721	// Indices
722	BOOST_UBLAS_INLINE
723	size_type index1 () const {
724	return it1_;
725	}
726	BOOST_UBLAS_INLINE
727	size_type index2 () const {
728	return it2_;
729	}
730
731	// Assignment
732	BOOST_UBLAS_INLINE
733	const_iterator2 &operator = (const const_iterator2 &it) {
734	container_const_reference<self_type>::assign (&it ());
735	it1_ = it.it1_;
736	it2_ = it.it2_;
737	return *this;
738	}
739
740	// Comparison
741	BOOST_UBLAS_INLINE
742	bool operator == (const const_iterator2 &it) const {
743	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
744	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
745	return it2_ == it.it2_;
746	}
747	BOOST_UBLAS_INLINE
748	bool operator < (const const_iterator2 &it) const {
749	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
750	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
751	return it2_ < it.it2_;
752	}
753
754	private:
755	size_type it1_;
756	size_type it2_;
757	};
758	#endif
759
760	BOOST_UBLAS_INLINE
761	const_iterator2 begin2 () const {
762	return find2 (0, 0, 0);
763	}
764	BOOST_UBLAS_INLINE
765	const_iterator2 end2 () const {
766	return find2 (0, 0, size2_);
767	}
768
769	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
770	class iterator2:
771	public container_reference<banded_matrix>,
772	public random_access_iterator_base<packed_random_access_iterator_tag,
773	iterator2, value_type> {
774	public:
775	typedef typename banded_matrix::value_type value_type;
776	typedef typename banded_matrix::difference_type difference_type;
777	typedef typename banded_matrix::reference reference;
778	typedef typename banded_matrix::pointer pointer;
779
780	typedef iterator1 dual_iterator_type;
781	typedef reverse_iterator1 dual_reverse_iterator_type;
782
783	// Construction and destruction
784	BOOST_UBLAS_INLINE
785	iterator2 ():
786	container_reference<self_type> (), it1_ (), it2_ () {}
787	BOOST_UBLAS_INLINE
788	iterator2 (self_type &m, size_type it1, size_type it2):
789	container_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
790
791	// Arithmetic
792	BOOST_UBLAS_INLINE
793	iterator2 &operator ++ () {
794	++ it2_;
795	return *this;
796	}
797	BOOST_UBLAS_INLINE
798	iterator2 &operator -- () {
799	-- it2_;
800	return *this;
801	}
802	BOOST_UBLAS_INLINE
803	iterator2 &operator += (difference_type n) {
804	it2_ += n;
805	return *this;
806	}
807	BOOST_UBLAS_INLINE
808	iterator2 &operator -= (difference_type n) {
809	it2_ -= n;
810	return *this;
811	}
812	BOOST_UBLAS_INLINE
813	difference_type operator - (const iterator2 &it) const {
814	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
815	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
816	return it2_ - it.it2_;
817	}
818
819	// Dereference
820	BOOST_UBLAS_INLINE
821	reference operator * () const {
822	return (*this) ().at_element (it1_, it2_);
823	}
824
825	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
826	BOOST_UBLAS_INLINE
827	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
828	typename self_type::
829	#endif
830	iterator1 begin () const {
831	return (*this) ().find1 (1, 0, it2_);
832	}
833	BOOST_UBLAS_INLINE
834	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
835	typename self_type::
836	#endif
837	iterator1 end () const {
838	return (this) ().find1 (1, (this) ().size1 (), it2_);
839	}
840	BOOST_UBLAS_INLINE
841	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
842	typename self_type::
843	#endif
844	reverse_iterator1 rbegin () const {
845	return reverse_iterator1 (end ());
846	}
847	BOOST_UBLAS_INLINE
848	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
849	typename self_type::
850	#endif
851	reverse_iterator1 rend () const {
852	return reverse_iterator1 (begin ());
853	}
854	#endif
855
856	// Indices
857	BOOST_UBLAS_INLINE
858	size_type index1 () const {
859	return it1_;
860	}
861	BOOST_UBLAS_INLINE
862	size_type index2 () const {
863	return it2_;
864	}
865
866	// Assignment
867	BOOST_UBLAS_INLINE
868	iterator2 &operator = (const iterator2 &it) {
869	container_reference<self_type>::assign (&it ());
870	it1_ = it.it1_;
871	it2_ = it.it2_;
872	return *this;
873	}
874
875	// Comparison
876	BOOST_UBLAS_INLINE
877	bool operator == (const iterator2 &it) const {
878	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
879	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
880	return it2_ == it.it2_;
881	}
882	BOOST_UBLAS_INLINE
883	bool operator < (const iterator2 &it) const {
884	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
885	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
886	return it2_ < it.it2_;
887	}
888
889	private:
890	size_type it1_;
891	size_type it2_;
892
893	friend class const_iterator2;
894	};
895	#endif
896
897	BOOST_UBLAS_INLINE
898	iterator2 begin2 () {
899	return find2 (0, 0, 0);
900	}
901	BOOST_UBLAS_INLINE
902	iterator2 end2 () {
903	return find2 (0, 0, size2_);
904	}
905
906	// Reverse iterators
907
908	BOOST_UBLAS_INLINE
909	const_reverse_iterator1 rbegin1 () const {
910	return const_reverse_iterator1 (end1 ());
911	}
912	BOOST_UBLAS_INLINE
913	const_reverse_iterator1 rend1 () const {
914	return const_reverse_iterator1 (begin1 ());
915	}
916
917	BOOST_UBLAS_INLINE
918	reverse_iterator1 rbegin1 () {
919	return reverse_iterator1 (end1 ());
920	}
921	BOOST_UBLAS_INLINE
922	reverse_iterator1 rend1 () {
923	return reverse_iterator1 (begin1 ());
924	}
925
926	BOOST_UBLAS_INLINE
927	const_reverse_iterator2 rbegin2 () const {
928	return const_reverse_iterator2 (end2 ());
929	}
930	BOOST_UBLAS_INLINE
931	const_reverse_iterator2 rend2 () const {
932	return const_reverse_iterator2 (begin2 ());
933	}
934
935	BOOST_UBLAS_INLINE
936	reverse_iterator2 rbegin2 () {
937	return reverse_iterator2 (end2 ());
938	}
939	BOOST_UBLAS_INLINE
940	reverse_iterator2 rend2 () {
941	return reverse_iterator2 (begin2 ());
942	}
943
944	private:
945	size_type size1_;
946	size_type size2_;
947	size_type lower_;
948	size_type upper_;
949	array_type data_;
950	typedef const value_type const_value_type;
951	static const_value_type zero_;
952	};
953
954	template<class T, class L, class A>
955	typename banded_matrix<T, L, A>::const_value_type banded_matrix<T, L, A>::zero_ = value_type/zero/();
956
957
958	// Diagonal matrix class
959	template<class T, class L, class A>
960	class diagonal_matrix:
961	public banded_matrix<T, L, A> {
962	public:
963	typedef typename A::size_type size_type;
964	typedef banded_matrix<T, L, A> matrix_type;
965	typedef A array_type;
966
967	// Construction and destruction
968	BOOST_UBLAS_INLINE
969	diagonal_matrix ():
970	matrix_type () {}
971	BOOST_UBLAS_INLINE
972	diagonal_matrix (size_type size):
973	matrix_type (size, size) {}
974	BOOST_UBLAS_INLINE
975	diagonal_matrix (size_type size, const array_type& data):
976	matrix_type (size, size, 0, 0, data) {}
977	BOOST_UBLAS_INLINE
978	diagonal_matrix (size_type size1, size_type size2):
979	matrix_type (size1, size2) {}
980	template<class AE>
981	BOOST_UBLAS_INLINE
982	diagonal_matrix (const matrix_expression<AE> &ae):
983	matrix_type (ae) {}
984	BOOST_UBLAS_INLINE
985	~diagonal_matrix () {}
986
987	// Assignment
988	BOOST_UBLAS_INLINE
989	diagonal_matrix &operator = (const diagonal_matrix &m) {
990	matrix_type::operator = (m);
991	return *this;
992	}
993	template<class AE>
994	BOOST_UBLAS_INLINE
995	diagonal_matrix &operator = (const matrix_expression<AE> &ae) {
996	matrix_type::operator = (ae);
997	return *this;
998	}
999	};
1000
1001	// Banded matrix adaptor class
1002	template<class M>
1003	class banded_adaptor:
1004	public matrix_expression<banded_adaptor<M> > {
1005
1006	typedef banded_adaptor<M> self_type;
1007	public:
1008	#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
1009	using matrix_expression<self_type>::operator ();
1010	#endif
1011	typedef const M const_matrix_type;
1012	typedef M matrix_type;
1013	typedef typename M::size_type size_type;
1014	typedef typename M::difference_type difference_type;
1015	typedef typename M::value_type value_type;
1016	typedef typename M::const_reference const_reference;
1017	typedef typename boost::mpl::if_<boost::is_const<M>,
1018	typename M::const_reference,
1019	typename M::reference>::type reference;
1020	typedef typename boost::mpl::if_<boost::is_const<M>,
1021	typename M::const_closure_type,
1022	typename M::closure_type>::type matrix_closure_type;
1023	typedef const self_type const_closure_type;
1024	typedef self_type closure_type;
1025	// Replaced by _temporary_traits to avoid type requirements on M
1026	//typedef typename M::vector_temporary_type vector_temporary_type;
1027	//typedef typename M::matrix_temporary_type matrix_temporary_type;
1028	typedef typename storage_restrict_traits<typename M::storage_category,
1029	packed_proxy_tag>::storage_category storage_category;
1030	typedef typename M::orientation_category orientation_category;
1031
1032	// Construction and destruction
1033	BOOST_UBLAS_INLINE
1034	banded_adaptor (matrix_type &data, size_type lower = 0, size_type upper = 0):
1035	matrix_expression<self_type> (),
1036	data_ (data), lower_ (lower), upper_ (upper) {}
1037	BOOST_UBLAS_INLINE
1038	banded_adaptor (const banded_adaptor &m):
1039	matrix_expression<self_type> (),
1040	data_ (m.data_), lower_ (m.lower_), upper_ (m.upper_) {}
1041
1042	// Accessors
1043	BOOST_UBLAS_INLINE
1044	size_type size1 () const {
1045	return data_.size1 ();
1046	}
1047	BOOST_UBLAS_INLINE
1048	size_type size2 () const {
1049	return data_.size2 ();
1050	}
1051	BOOST_UBLAS_INLINE
1052	size_type lower () const {
1053	return lower_;
1054	}
1055	BOOST_UBLAS_INLINE
1056	size_type upper () const {
1057	return upper_;
1058	}
1059
1060	// Storage accessors
1061	BOOST_UBLAS_INLINE
1062	const matrix_closure_type &data () const {
1063	return data_;
1064	}
1065	BOOST_UBLAS_INLINE
1066	matrix_closure_type &data () {
1067	return data_;
1068	}
1069
1070	// Element access
1071	#ifndef BOOST_UBLAS_PROXY_CONST_MEMBER
1072	BOOST_UBLAS_INLINE
1073	const_reference operator () (size_type i, size_type j) const {
1074	BOOST_UBLAS_CHECK (i < size1 (), bad_index ());
1075	BOOST_UBLAS_CHECK (j < size2 (), bad_index ());
1076	#ifdef BOOST_UBLAS_OWN_BANDED
1077	size_type k = (std::max) (i, j);
1078	size_type l = lower_ + j - i;
1079	if (k < (std::max) (size1 (), size2 ()) &&
1080	l < lower_ + 1 + upper_)
1081	return data () (i, j);
1082	#else
1083	size_type k = j;
1084	size_type l = upper_ + i - j;
1085	if (k < size2 () &&
1086	l < lower_ + 1 + upper_)
1087	return data () (i, j);
1088	#endif
1089	return zero_;
1090	}
1091	BOOST_UBLAS_INLINE
1092	reference operator () (size_type i, size_type j) {
1093	BOOST_UBLAS_CHECK (i < size1 (), bad_index ());
1094	BOOST_UBLAS_CHECK (j < size2 (), bad_index ());
1095	#ifdef BOOST_UBLAS_OWN_BANDED
1096	size_type k = (std::max) (i, j);
1097	size_type l = lower_ + j - i;
1098	if (k < (std::max) (size1 (), size2 ()) &&
1099	l < lower_ + 1 + upper_)
1100	return data () (i, j);
1101	#else
1102	size_type k = j;
1103	size_type l = upper_ + i - j;
1104	if (k < size2 () &&
1105	l < lower_ + 1 + upper_)
1106	return data () (i, j);
1107	#endif
1108	#ifndef BOOST_UBLAS_REFERENCE_CONST_MEMBER
1109	bad_index ().raise ();
1110	#endif
1111	return const_cast<reference>(zero_);
1112	}
1113	#else
1114	BOOST_UBLAS_INLINE
1115	reference operator () (size_type i, size_type j) const {
1116	BOOST_UBLAS_CHECK (i < size1 (), bad_index ());
1117	BOOST_UBLAS_CHECK (j < size2 (), bad_index ());
1118	#ifdef BOOST_UBLAS_OWN_BANDED
1119	size_type k = (std::max) (i, j);
1120	size_type l = lower_ + j - i;
1121	if (k < (std::max) (size1 (), size2 ()) &&
1122	l < lower_ + 1 + upper_)
1123	return data () (i, j);
1124	#else
1125	size_type k = j;
1126	size_type l = upper_ + i - j;
1127	if (k < size2 () &&
1128	l < lower_ + 1 + upper_)
1129	return data () (i, j);
1130	#endif
1131	#ifndef BOOST_UBLAS_REFERENCE_CONST_MEMBER
1132	bad_index ().raise ();
1133	#endif
1134	return const_cast<reference>(zero_);
1135	}
1136	#endif
1137
1138	// Assignment
1139	BOOST_UBLAS_INLINE
1140	banded_adaptor &operator = (const banded_adaptor &m) {
1141	matrix_assign<scalar_assign> (*this, m);
1142	return *this;
1143	}
1144	BOOST_UBLAS_INLINE
1145	banded_adaptor &assign_temporary (banded_adaptor &m) {
1146	*this = m;
1147	return *this;
1148	}
1149	template<class AE>
1150	BOOST_UBLAS_INLINE
1151	banded_adaptor &operator = (const matrix_expression<AE> &ae) {
1152	matrix_assign<scalar_assign> (*this, matrix<value_type> (ae));
1153	return *this;
1154	}
1155	template<class AE>
1156	BOOST_UBLAS_INLINE
1157	banded_adaptor &assign (const matrix_expression<AE> &ae) {
1158	matrix_assign<scalar_assign> (*this, ae);
1159	return *this;
1160	}
1161	template<class AE>
1162	BOOST_UBLAS_INLINE
1163	banded_adaptor& operator += (const matrix_expression<AE> &ae) {
1164	matrix_assign<scalar_assign> (this, matrix<value_type> (this + ae));
1165	return *this;
1166	}
1167	template<class AE>
1168	BOOST_UBLAS_INLINE
1169	banded_adaptor &plus_assign (const matrix_expression<AE> &ae) {
1170	matrix_assign<scalar_plus_assign> (*this, ae);
1171	return *this;
1172	}
1173	template<class AE>
1174	BOOST_UBLAS_INLINE
1175	banded_adaptor& operator -= (const matrix_expression<AE> &ae) {
1176	matrix_assign<scalar_assign> (this, matrix<value_type> (this - ae));
1177	return *this;
1178	}
1179	template<class AE>
1180	BOOST_UBLAS_INLINE
1181	banded_adaptor &minus_assign (const matrix_expression<AE> &ae) {
1182	matrix_assign<scalar_minus_assign> (*this, ae);
1183	return *this;
1184	}
1185	template<class AT>
1186	BOOST_UBLAS_INLINE
1187	banded_adaptor& operator *= (const AT &at) {
1188	matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
1189	return *this;
1190	}
1191	template<class AT>
1192	BOOST_UBLAS_INLINE
1193	banded_adaptor& operator /= (const AT &at) {
1194	matrix_assign_scalar<scalar_divides_assign> (*this, at);
1195	return *this;
1196	}
1197
1198	// Closure comparison
1199	BOOST_UBLAS_INLINE
1200	bool same_closure (const banded_adaptor &ba) const {
1201	return (*this).data ().same_closure (ba.data ());
1202	}
1203
1204	// Swapping
1205	BOOST_UBLAS_INLINE
1206	void swap (banded_adaptor &m) {
1207	if (this != &m) {
1208	BOOST_UBLAS_CHECK (lower_ == m.lower_, bad_size ());
1209	BOOST_UBLAS_CHECK (upper_ == m.upper_, bad_size ());
1210	matrix_swap<scalar_swap> (*this, m);
1211	}
1212	}
1213	BOOST_UBLAS_INLINE
1214	friend void swap (banded_adaptor &m1, banded_adaptor &m2) {
1215	m1.swap (m2);
1216	}
1217
1218	// Iterator types
1219	private:
1220	// Use the matrix iterator
1221	typedef typename M::const_iterator1 const_subiterator1_type;
1222	typedef typename boost::mpl::if_<boost::is_const<M>,
1223	typename M::const_iterator1,
1224	typename M::iterator1>::type subiterator1_type;
1225	typedef typename M::const_iterator2 const_subiterator2_type;
1226	typedef typename boost::mpl::if_<boost::is_const<M>,
1227	typename M::const_iterator2,
1228	typename M::iterator2>::type subiterator2_type;
1229
1230	public:
1231	#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
1232	typedef indexed_iterator1<self_type, packed_random_access_iterator_tag> iterator1;
1233	typedef indexed_iterator2<self_type, packed_random_access_iterator_tag> iterator2;
1234	typedef indexed_const_iterator1<self_type, packed_random_access_iterator_tag> const_iterator1;
1235	typedef indexed_const_iterator2<self_type, packed_random_access_iterator_tag> const_iterator2;
1236	#else
1237	class const_iterator1;
1238	class iterator1;
1239	class const_iterator2;
1240	class iterator2;
1241	#endif
1242	typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
1243	typedef reverse_iterator_base1<iterator1> reverse_iterator1;
1244	typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
1245	typedef reverse_iterator_base2<iterator2> reverse_iterator2;
1246
1247	// Element lookup
1248	BOOST_UBLAS_INLINE
1249	const_iterator1 find1 (int rank, size_type i, size_type j) const {
1250	if (rank == 1) {
1251	size_type lower_i = (std::max) (difference_type (j - upper_), difference_type (0));
1252	i = (std::max) (i, lower_i);
1253	size_type upper_i = (std::min) (j + 1 + lower_, size1 ());
1254	i = (std::min) (i, upper_i);
1255	}
1256	return const_iterator1 (*this, data ().find1 (rank, i, j));
1257	}
1258	BOOST_UBLAS_INLINE
1259	iterator1 find1 (int rank, size_type i, size_type j) {
1260	if (rank == 1) {
1261	size_type lower_i = (std::max) (difference_type (j - upper_), difference_type (0));
1262	i = (std::max) (i, lower_i);
1263	size_type upper_i = (std::min) (j + 1 + lower_, size1 ());
1264	i = (std::min) (i, upper_i);
1265	}
1266	return iterator1 (*this, data ().find1 (rank, i, j));
1267	}
1268	BOOST_UBLAS_INLINE
1269	const_iterator2 find2 (int rank, size_type i, size_type j) const {
1270	if (rank == 1) {
1271	size_type lower_j = (std::max) (difference_type (i - lower_), difference_type (0));
1272	j = (std::max) (j, lower_j);
1273	size_type upper_j = (std::min) (i + 1 + upper_, size2 ());
1274	j = (std::min) (j, upper_j);
1275	}
1276	return const_iterator2 (*this, data ().find2 (rank, i, j));
1277	}
1278	BOOST_UBLAS_INLINE
1279	iterator2 find2 (int rank, size_type i, size_type j) {
1280	if (rank == 1) {
1281	size_type lower_j = (std::max) (difference_type (i - lower_), difference_type (0));
1282	j = (std::max) (j, lower_j);
1283	size_type upper_j = (std::min) (i + 1 + upper_, size2 ());
1284	j = (std::min) (j, upper_j);
1285	}
1286	return iterator2 (*this, data ().find2 (rank, i, j));
1287	}
1288
1289	// Iterators simply are indices.
1290
1291	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1292	class const_iterator1:
1293	public container_const_reference<banded_adaptor>,
1294	public random_access_iterator_base<typename iterator_restrict_traits<
1295	typename const_subiterator1_type::iterator_category, packed_random_access_iterator_tag>::iterator_category,
1296	const_iterator1, value_type> {
1297	public:
1298	typedef typename const_subiterator1_type::value_type value_type;
1299	typedef typename const_subiterator1_type::difference_type difference_type;
1300	typedef typename const_subiterator1_type::reference reference;
1301	typedef typename const_subiterator1_type::pointer pointer;
1302
1303	typedef const_iterator2 dual_iterator_type;
1304	typedef const_reverse_iterator2 dual_reverse_iterator_type;
1305
1306	// Construction and destruction
1307	BOOST_UBLAS_INLINE
1308	const_iterator1 ():
1309	container_const_reference<self_type> (), it1_ () {}
1310	BOOST_UBLAS_INLINE
1311	const_iterator1 (const self_type &m, const const_subiterator1_type &it1):
1312	container_const_reference<self_type> (m), it1_ (it1) {}
1313	BOOST_UBLAS_INLINE
1314	const_iterator1 (const iterator1 &it):
1315	container_const_reference<self_type> (it ()), it1_ (it.it1_) {}
1316
1317	// Arithmetic
1318	BOOST_UBLAS_INLINE
1319	const_iterator1 &operator ++ () {
1320	++ it1_;
1321	return *this;
1322	}
1323	BOOST_UBLAS_INLINE
1324	const_iterator1 &operator -- () {
1325	-- it1_;
1326	return *this;
1327	}
1328	BOOST_UBLAS_INLINE
1329	const_iterator1 &operator += (difference_type n) {
1330	it1_ += n;
1331	return *this;
1332	}
1333	BOOST_UBLAS_INLINE
1334	const_iterator1 &operator -= (difference_type n) {
1335	it1_ -= n;
1336	return *this;
1337	}
1338	BOOST_UBLAS_INLINE
1339	difference_type operator - (const const_iterator1 &it) const {
1340	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1341	return it1_ - it.it1_;
1342	}
1343
1344	// Dereference
1345	BOOST_UBLAS_INLINE
1346	const_reference operator * () const {
1347	size_type i = index1 ();
1348	size_type j = index2 ();
1349	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
1350	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
1351	#ifdef BOOST_UBLAS_OWN_BANDED
1352	size_type k = (std::max) (i, j);
1353	size_type l = (*this) ().lower () + j - i;
1354	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
1355	l < (this) ().lower () + 1 + (this) ().upper ())
1356	return *it1_;
1357	#else
1358	size_type k = j;
1359	size_type l = (*this) ().upper () + i - j;
1360	if (k < (*this) ().size2 () &&
1361	l < (this) ().lower () + 1 + (this) ().upper ())
1362	return *it1_;
1363	#endif
1364	return (*this) () (i, j);
1365	}
1366
1367	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1368	BOOST_UBLAS_INLINE
1369	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1370	typename self_type::
1371	#endif
1372	const_iterator2 begin () const {
1373	return (*this) ().find2 (1, index1 (), 0);
1374	}
1375	BOOST_UBLAS_INLINE
1376	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1377	typename self_type::
1378	#endif
1379	const_iterator2 end () const {
1380	return (this) ().find2 (1, index1 (), (this) ().size2 ());
1381	}
1382	BOOST_UBLAS_INLINE
1383	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1384	typename self_type::
1385	#endif
1386	const_reverse_iterator2 rbegin () const {
1387	return const_reverse_iterator2 (end ());
1388	}
1389	BOOST_UBLAS_INLINE
1390	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1391	typename self_type::
1392	#endif
1393	const_reverse_iterator2 rend () const {
1394	return const_reverse_iterator2 (begin ());
1395	}
1396	#endif
1397
1398	// Indices
1399	BOOST_UBLAS_INLINE
1400	size_type index1 () const {
1401	return it1_.index1 ();
1402	}
1403	BOOST_UBLAS_INLINE
1404	size_type index2 () const {
1405	return it1_.index2 ();
1406	}
1407
1408	// Assignment
1409	BOOST_UBLAS_INLINE
1410	const_iterator1 &operator = (const const_iterator1 &it) {
1411	container_const_reference<self_type>::assign (&it ());
1412	it1_ = it.it1_;
1413	return *this;
1414	}
1415
1416	// Comparison
1417	BOOST_UBLAS_INLINE
1418	bool operator == (const const_iterator1 &it) const {
1419	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1420	return it1_ == it.it1_;
1421	}
1422	BOOST_UBLAS_INLINE
1423	bool operator < (const const_iterator1 &it) const {
1424	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1425	return it1_ < it.it1_;
1426	}
1427
1428	private:
1429	const_subiterator1_type it1_;
1430	};
1431	#endif
1432
1433	BOOST_UBLAS_INLINE
1434	const_iterator1 begin1 () const {
1435	return find1 (0, 0, 0);
1436	}
1437	BOOST_UBLAS_INLINE
1438	const_iterator1 end1 () const {
1439	return find1 (0, size1 (), 0);
1440	}
1441
1442	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1443	class iterator1:
1444	public container_reference<banded_adaptor>,
1445	public random_access_iterator_base<typename iterator_restrict_traits<
1446	typename subiterator1_type::iterator_category, packed_random_access_iterator_tag>::iterator_category,
1447	iterator1, value_type> {
1448	public:
1449	typedef typename subiterator1_type::value_type value_type;
1450	typedef typename subiterator1_type::difference_type difference_type;
1451	typedef typename subiterator1_type::reference reference;
1452	typedef typename subiterator1_type::pointer pointer;
1453
1454	typedef iterator2 dual_iterator_type;
1455	typedef reverse_iterator2 dual_reverse_iterator_type;
1456
1457	// Construction and destruction
1458	BOOST_UBLAS_INLINE
1459	iterator1 ():
1460	container_reference<self_type> (), it1_ () {}
1461	BOOST_UBLAS_INLINE
1462	iterator1 (self_type &m, const subiterator1_type &it1):
1463	container_reference<self_type> (m), it1_ (it1) {}
1464
1465	// Arithmetic
1466	BOOST_UBLAS_INLINE
1467	iterator1 &operator ++ () {
1468	++ it1_;
1469	return *this;
1470	}
1471	BOOST_UBLAS_INLINE
1472	iterator1 &operator -- () {
1473	-- it1_;
1474	return *this;
1475	}
1476	BOOST_UBLAS_INLINE
1477	iterator1 &operator += (difference_type n) {
1478	it1_ += n;
1479	return *this;
1480	}
1481	BOOST_UBLAS_INLINE
1482	iterator1 &operator -= (difference_type n) {
1483	it1_ -= n;
1484	return *this;
1485	}
1486	BOOST_UBLAS_INLINE
1487	difference_type operator - (const iterator1 &it) const {
1488	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1489	return it1_ - it.it1_;
1490	}
1491
1492	// Dereference
1493	BOOST_UBLAS_INLINE
1494	reference operator * () const {
1495	size_type i = index1 ();
1496	size_type j = index2 ();
1497	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
1498	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
1499	#ifdef BOOST_UBLAS_OWN_BANDED
1500	size_type k = (std::max) (i, j);
1501	size_type l = (*this) ().lower () + j - i;
1502	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
1503	l < (this) ().lower () + 1 + (this) ().upper ())
1504	return *it1_;
1505	#else
1506	size_type k = j;
1507	size_type l = (*this) ().upper () + i - j;
1508	if (k < (*this) ().size2 () &&
1509	l < (this) ().lower () + 1 + (this) ().upper ())
1510	return *it1_;
1511	#endif
1512	return (*this) () (i, j);
1513	}
1514
1515	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1516	BOOST_UBLAS_INLINE
1517	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1518	typename self_type::
1519	#endif
1520	iterator2 begin () const {
1521	return (*this) ().find2 (1, index1 (), 0);
1522	}
1523	BOOST_UBLAS_INLINE
1524	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1525	typename self_type::
1526	#endif
1527	iterator2 end () const {
1528	return (this) ().find2 (1, index1 (), (this) ().size2 ());
1529	}
1530	BOOST_UBLAS_INLINE
1531	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1532	typename self_type::
1533	#endif
1534	reverse_iterator2 rbegin () const {
1535	return reverse_iterator2 (end ());
1536	}
1537	BOOST_UBLAS_INLINE
1538	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1539	typename self_type::
1540	#endif
1541	reverse_iterator2 rend () const {
1542	return reverse_iterator2 (begin ());
1543	}
1544	#endif
1545
1546	// Indices
1547	BOOST_UBLAS_INLINE
1548	size_type index1 () const {
1549	return it1_.index1 ();
1550	}
1551	BOOST_UBLAS_INLINE
1552	size_type index2 () const {
1553	return it1_.index2 ();
1554	}
1555
1556	// Assignment
1557	BOOST_UBLAS_INLINE
1558	iterator1 &operator = (const iterator1 &it) {
1559	container_reference<self_type>::assign (&it ());
1560	it1_ = it.it1_;
1561	return *this;
1562	}
1563
1564	// Comparison
1565	BOOST_UBLAS_INLINE
1566	bool operator == (const iterator1 &it) const {
1567	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1568	return it1_ == it.it1_;
1569	}
1570	BOOST_UBLAS_INLINE
1571	bool operator < (const iterator1 &it) const {
1572	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1573	return it1_ < it.it1_;
1574	}
1575
1576	private:
1577	subiterator1_type it1_;
1578
1579	friend class const_iterator1;
1580	};
1581	#endif
1582
1583	BOOST_UBLAS_INLINE
1584	iterator1 begin1 () {
1585	return find1 (0, 0, 0);
1586	}
1587	BOOST_UBLAS_INLINE
1588	iterator1 end1 () {
1589	return find1 (0, size1 (), 0);
1590	}
1591
1592	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1593	class const_iterator2:
1594	public container_const_reference<banded_adaptor>,
1595	public random_access_iterator_base<packed_random_access_iterator_tag,
1596	const_iterator2, value_type> {
1597	public:
1598	typedef typename iterator_restrict_traits<typename const_subiterator2_type::iterator_category,
1599	packed_random_access_iterator_tag>::iterator_category iterator_category;
1600	typedef typename const_subiterator2_type::value_type value_type;
1601	typedef typename const_subiterator2_type::difference_type difference_type;
1602	typedef typename const_subiterator2_type::reference reference;
1603	typedef typename const_subiterator2_type::pointer pointer;
1604
1605	typedef const_iterator1 dual_iterator_type;
1606	typedef const_reverse_iterator1 dual_reverse_iterator_type;
1607
1608	// Construction and destruction
1609	BOOST_UBLAS_INLINE
1610	const_iterator2 ():
1611	container_const_reference<self_type> (), it2_ () {}
1612	BOOST_UBLAS_INLINE
1613	const_iterator2 (const self_type &m, const const_subiterator2_type &it2):
1614	container_const_reference<self_type> (m), it2_ (it2) {}
1615	BOOST_UBLAS_INLINE
1616	const_iterator2 (const iterator2 &it):
1617	container_const_reference<self_type> (it ()), it2_ (it.it2_) {}
1618
1619	// Arithmetic
1620	BOOST_UBLAS_INLINE
1621	const_iterator2 &operator ++ () {
1622	++ it2_;
1623	return *this;
1624	}
1625	BOOST_UBLAS_INLINE
1626	const_iterator2 &operator -- () {
1627	-- it2_;
1628	return *this;
1629	}
1630	BOOST_UBLAS_INLINE
1631	const_iterator2 &operator += (difference_type n) {
1632	it2_ += n;
1633	return *this;
1634	}
1635	BOOST_UBLAS_INLINE
1636	const_iterator2 &operator -= (difference_type n) {
1637	it2_ -= n;
1638	return *this;
1639	}
1640	BOOST_UBLAS_INLINE
1641	difference_type operator - (const const_iterator2 &it) const {
1642	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1643	return it2_ - it.it2_;
1644	}
1645
1646	// Dereference
1647	BOOST_UBLAS_INLINE
1648	const_reference operator * () const {
1649	size_type i = index1 ();
1650	size_type j = index2 ();
1651	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
1652	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
1653	#ifdef BOOST_UBLAS_OWN_BANDED
1654	size_type k = (std::max) (i, j);
1655	size_type l = (*this) ().lower () + j - i;
1656	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
1657	l < (this) ().lower () + 1 + (this) ().upper ())
1658	return *it2_;
1659	#else
1660	size_type k = j;
1661	size_type l = (*this) ().upper () + i - j;
1662	if (k < (*this) ().size2 () &&
1663	l < (this) ().lower () + 1 + (this) ().upper ())
1664	return *it2_;
1665	#endif
1666	return (*this) () (i, j);
1667	}
1668
1669	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1670	BOOST_UBLAS_INLINE
1671	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1672	typename self_type::
1673	#endif
1674	const_iterator1 begin () const {
1675	return (*this) ().find1 (1, 0, index2 ());
1676	}
1677	BOOST_UBLAS_INLINE
1678	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1679	typename self_type::
1680	#endif
1681	const_iterator1 end () const {
1682	return (this) ().find1 (1, (this) ().size1 (), index2 ());
1683	}
1684	BOOST_UBLAS_INLINE
1685	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1686	typename self_type::
1687	#endif
1688	const_reverse_iterator1 rbegin () const {
1689	return const_reverse_iterator1 (end ());
1690	}
1691	BOOST_UBLAS_INLINE
1692	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1693	typename self_type::
1694	#endif
1695	const_reverse_iterator1 rend () const {
1696	return const_reverse_iterator1 (begin ());
1697	}
1698	#endif
1699
1700	// Indices
1701	BOOST_UBLAS_INLINE
1702	size_type index1 () const {
1703	return it2_.index1 ();
1704	}
1705	BOOST_UBLAS_INLINE
1706	size_type index2 () const {
1707	return it2_.index2 ();
1708	}
1709
1710	// Assignment
1711	BOOST_UBLAS_INLINE
1712	const_iterator2 &operator = (const const_iterator2 &it) {
1713	container_const_reference<self_type>::assign (&it ());
1714	it2_ = it.it2_;
1715	return *this;
1716	}
1717
1718	// Comparison
1719	BOOST_UBLAS_INLINE
1720	bool operator == (const const_iterator2 &it) const {
1721	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1722	return it2_ == it.it2_;
1723	}
1724	BOOST_UBLAS_INLINE
1725	bool operator < (const const_iterator2 &it) const {
1726	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1727	return it2_ < it.it2_;
1728	}
1729
1730	private:
1731	const_subiterator2_type it2_;
1732	};
1733	#endif
1734
1735	BOOST_UBLAS_INLINE
1736	const_iterator2 begin2 () const {
1737	return find2 (0, 0, 0);
1738	}
1739	BOOST_UBLAS_INLINE
1740	const_iterator2 end2 () const {
1741	return find2 (0, 0, size2 ());
1742	}
1743
1744	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
1745	class iterator2:
1746	public container_reference<banded_adaptor>,
1747	public random_access_iterator_base<typename iterator_restrict_traits<
1748	typename subiterator2_type::iterator_category, packed_random_access_iterator_tag>::iterator_category,
1749	iterator2, value_type> {
1750	public:
1751	typedef typename subiterator2_type::value_type value_type;
1752	typedef typename subiterator2_type::difference_type difference_type;
1753	typedef typename subiterator2_type::reference reference;
1754	typedef typename subiterator2_type::pointer pointer;
1755
1756	typedef iterator1 dual_iterator_type;
1757	typedef reverse_iterator1 dual_reverse_iterator_type;
1758
1759	// Construction and destruction
1760	BOOST_UBLAS_INLINE
1761	iterator2 ():
1762	container_reference<self_type> (), it2_ () {}
1763	BOOST_UBLAS_INLINE
1764	iterator2 (self_type &m, const subiterator2_type &it2):
1765	container_reference<self_type> (m), it2_ (it2) {}
1766
1767	// Arithmetic
1768	BOOST_UBLAS_INLINE
1769	iterator2 &operator ++ () {
1770	++ it2_;
1771	return *this;
1772	}
1773	BOOST_UBLAS_INLINE
1774	iterator2 &operator -- () {
1775	-- it2_;
1776	return *this;
1777	}
1778	BOOST_UBLAS_INLINE
1779	iterator2 &operator += (difference_type n) {
1780	it2_ += n;
1781	return *this;
1782	}
1783	BOOST_UBLAS_INLINE
1784	iterator2 &operator -= (difference_type n) {
1785	it2_ -= n;
1786	return *this;
1787	}
1788	BOOST_UBLAS_INLINE
1789	difference_type operator - (const iterator2 &it) const {
1790	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1791	return it2_ - it.it2_;
1792	}
1793
1794	// Dereference
1795	BOOST_UBLAS_INLINE
1796	reference operator * () const {
1797	size_type i = index1 ();
1798	size_type j = index2 ();
1799	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
1800	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
1801	#ifdef BOOST_UBLAS_OWN_BANDED
1802	size_type k = (std::max) (i, j);
1803	size_type l = (*this) ().lower () + j - i;
1804	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
1805	l < (this) ().lower () + 1 + (this) ().upper ())
1806	return *it2_;
1807	#else
1808	size_type k = j;
1809	size_type l = (*this) ().upper () + i - j;
1810	if (k < (*this) ().size2 () &&
1811	l < (this) ().lower () + 1 + (this) ().upper ())
1812	return *it2_;
1813	#endif
1814	return (*this) () (i, j);
1815	}
1816
1817	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
1818	BOOST_UBLAS_INLINE
1819	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1820	typename self_type::
1821	#endif
1822	iterator1 begin () const {
1823	return (*this) ().find1 (1, 0, index2 ());
1824	}
1825	BOOST_UBLAS_INLINE
1826	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1827	typename self_type::
1828	#endif
1829	iterator1 end () const {
1830	return (this) ().find1 (1, (this) ().size1 (), index2 ());
1831	}
1832	BOOST_UBLAS_INLINE
1833	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1834	typename self_type::
1835	#endif
1836	reverse_iterator1 rbegin () const {
1837	return reverse_iterator1 (end ());
1838	}
1839	BOOST_UBLAS_INLINE
1840	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
1841	typename self_type::
1842	#endif
1843	reverse_iterator1 rend () const {
1844	return reverse_iterator1 (begin ());
1845	}
1846	#endif
1847
1848	// Indices
1849	BOOST_UBLAS_INLINE
1850	size_type index1 () const {
1851	return it2_.index1 ();
1852	}
1853	BOOST_UBLAS_INLINE
1854	size_type index2 () const {
1855	return it2_.index2 ();
1856	}
1857
1858	// Assignment
1859	BOOST_UBLAS_INLINE
1860	iterator2 &operator = (const iterator2 &it) {
1861	container_reference<self_type>::assign (&it ());
1862	it2_ = it.it2_;
1863	return *this;
1864	}
1865
1866	// Comparison
1867	BOOST_UBLAS_INLINE
1868	bool operator == (const iterator2 &it) const {
1869	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1870	return it2_ == it.it2_;
1871	}
1872	BOOST_UBLAS_INLINE
1873	bool operator < (const iterator2 &it) const {
1874	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
1875	return it2_ < it.it2_;
1876	}
1877
1878	private:
1879	subiterator2_type it2_;
1880
1881	friend class const_iterator2;
1882	};
1883	#endif
1884
1885	BOOST_UBLAS_INLINE
1886	iterator2 begin2 () {
1887	return find2 (0, 0, 0);
1888	}
1889	BOOST_UBLAS_INLINE
1890	iterator2 end2 () {
1891	return find2 (0, 0, size2 ());
1892	}
1893
1894	// Reverse iterators
1895
1896	BOOST_UBLAS_INLINE
1897	const_reverse_iterator1 rbegin1 () const {
1898	return const_reverse_iterator1 (end1 ());
1899	}
1900	BOOST_UBLAS_INLINE
1901	const_reverse_iterator1 rend1 () const {
1902	return const_reverse_iterator1 (begin1 ());
1903	}
1904
1905	BOOST_UBLAS_INLINE
1906	reverse_iterator1 rbegin1 () {
1907	return reverse_iterator1 (end1 ());
1908	}
1909	BOOST_UBLAS_INLINE
1910	reverse_iterator1 rend1 () {
1911	return reverse_iterator1 (begin1 ());
1912	}
1913
1914	BOOST_UBLAS_INLINE
1915	const_reverse_iterator2 rbegin2 () const {
1916	return const_reverse_iterator2 (end2 ());
1917	}
1918	BOOST_UBLAS_INLINE
1919	const_reverse_iterator2 rend2 () const {
1920	return const_reverse_iterator2 (begin2 ());
1921	}
1922
1923	BOOST_UBLAS_INLINE
1924	reverse_iterator2 rbegin2 () {
1925	return reverse_iterator2 (end2 ());
1926	}
1927	BOOST_UBLAS_INLINE
1928	reverse_iterator2 rend2 () {
1929	return reverse_iterator2 (begin2 ());
1930	}
1931
1932	private:
1933	matrix_closure_type data_;
1934	size_type lower_;
1935	size_type upper_;
1936	typedef const value_type const_value_type;
1937	static const_value_type zero_;
1938	};
1939
1940	// Specialization for temporary_traits
1941	template <class M>
1942	struct vector_temporary_traits< banded_adaptor<M> >
1943	: vector_temporary_traits< M > {} ;
1944
1945	template <class M>
1946	struct matrix_temporary_traits< banded_adaptor<M> >
1947	: matrix_temporary_traits< M > {} ;
1948
1949
1950	template<class M>
1951	typename banded_adaptor<M>::const_value_type banded_adaptor<M>::zero_ = value_type/zero/();
1952
1953	// Diagonal matrix adaptor class
1954	template<class M>
1955	class diagonal_adaptor:
1956	public banded_adaptor<M> {
1957	public:
1958	typedef M matrix_type;
1959	typedef banded_adaptor<M> adaptor_type;
1960
1961	// Construction and destruction
1962	BOOST_UBLAS_INLINE
1963	diagonal_adaptor ():
1964	adaptor_type () {}
1965	BOOST_UBLAS_INLINE
1966	diagonal_adaptor (matrix_type &data):
1967	adaptor_type (data) {}
1968	BOOST_UBLAS_INLINE
1969	~diagonal_adaptor () {}
1970
1971	// Assignment
1972	BOOST_UBLAS_INLINE
1973	diagonal_adaptor &operator = (const diagonal_adaptor &m) {
1974	adaptor_type::operator = (m);
1975	return *this;
1976	}
1977	template<class AE>
1978	BOOST_UBLAS_INLINE
1979	diagonal_adaptor &operator = (const matrix_expression<AE> &ae) {
1980	adaptor_type::operator = (ae);
1981	return *this;
1982	}
1983	};
1984
1985	}}}
1986
1987	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: NonGTP/Boost/boost/numeric/ublas/banded.hpp @ 857

Download in other formats: