Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_34_1/boost/numeric/ublas/banded.hpp @ 30

Last change on this file since 30 was 29, checked in by landauf, 17 years ago
updated boost from 1_33_1 to 1_34_1
File size: 71.6 KB

Rev	Line
[29]	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	BOOST_UBLAS_INLINE
	415	const_reference operator [] (difference_type n) const {
	416	return (this + n);
	417	}
	418
	419	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	420	BOOST_UBLAS_INLINE
	421	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	422	typename self_type::
	423	#endif
	424	const_iterator2 begin () const {
	425	return (*this) ().find2 (1, it1_, 0);
	426	}
	427	BOOST_UBLAS_INLINE
	428	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	429	typename self_type::
	430	#endif
	431	const_iterator2 end () const {
	432	return (this) ().find2 (1, it1_, (this) ().size2 ());
	433	}
	434	BOOST_UBLAS_INLINE
	435	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	436	typename self_type::
	437	#endif
	438	const_reverse_iterator2 rbegin () const {
	439	return const_reverse_iterator2 (end ());
	440	}
	441	BOOST_UBLAS_INLINE
	442	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	443	typename self_type::
	444	#endif
	445	const_reverse_iterator2 rend () const {
	446	return const_reverse_iterator2 (begin ());
	447	}
	448	#endif
	449
	450	// Indices
	451	BOOST_UBLAS_INLINE
	452	size_type index1 () const {
	453	return it1_;
	454	}
	455	BOOST_UBLAS_INLINE
	456	size_type index2 () const {
	457	return it2_;
	458	}
	459
	460	// Assignment
	461	BOOST_UBLAS_INLINE
	462	const_iterator1 &operator = (const const_iterator1 &it) {
	463	container_const_reference<self_type>::assign (&it ());
	464	it1_ = it.it1_;
	465	it2_ = it.it2_;
	466	return *this;
	467	}
	468
	469	// Comparison
	470	BOOST_UBLAS_INLINE
	471	bool operator == (const const_iterator1 &it) const {
	472	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	473	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
	474	return it1_ == it.it1_;
	475	}
	476	BOOST_UBLAS_INLINE
	477	bool operator < (const const_iterator1 &it) const {
	478	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	479	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
	480	return it1_ < it.it1_;
	481	}
	482
	483	private:
	484	size_type it1_;
	485	size_type it2_;
	486	};
	487	#endif
	488
	489	BOOST_UBLAS_INLINE
	490	const_iterator1 begin1 () const {
	491	return find1 (0, 0, 0);
	492	}
	493	BOOST_UBLAS_INLINE
	494	const_iterator1 end1 () const {
	495	return find1 (0, size1_, 0);
	496	}
	497
	498	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	499	class iterator1:
	500	public container_reference<banded_matrix>,
	501	public random_access_iterator_base<packed_random_access_iterator_tag,
	502	iterator1, value_type> {
	503	public:
	504	typedef typename banded_matrix::value_type value_type;
	505	typedef typename banded_matrix::difference_type difference_type;
	506	typedef typename banded_matrix::reference reference;
	507	typedef typename banded_matrix::pointer pointer;
	508
	509	typedef iterator2 dual_iterator_type;
	510	typedef reverse_iterator2 dual_reverse_iterator_type;
	511
	512	// Construction and destruction
	513	BOOST_UBLAS_INLINE
	514	iterator1 ():
	515	container_reference<self_type> (), it1_ (), it2_ () {}
	516	BOOST_UBLAS_INLINE
	517	iterator1 (self_type &m, size_type it1, size_type it2):
	518	container_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
	519
	520	// Arithmetic
	521	BOOST_UBLAS_INLINE
	522	iterator1 &operator ++ () {
	523	++ it1_;
	524	return *this;
	525	}
	526	BOOST_UBLAS_INLINE
	527	iterator1 &operator -- () {
	528	-- it1_;
	529	return *this;
	530	}
	531	BOOST_UBLAS_INLINE
	532	iterator1 &operator += (difference_type n) {
	533	it1_ += n;
	534	return *this;
	535	}
	536	BOOST_UBLAS_INLINE
	537	iterator1 &operator -= (difference_type n) {
	538	it1_ -= n;
	539	return *this;
	540	}
	541	BOOST_UBLAS_INLINE
	542	difference_type operator - (const iterator1 &it) const {
	543	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	544	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
	545	return it1_ - it.it1_;
	546	}
	547
	548	// Dereference
	549	BOOST_UBLAS_INLINE
	550	reference operator * () const {
	551	return (*this) ().at_element (it1_, it2_);
	552	}
	553	BOOST_UBLAS_INLINE
	554	reference operator [] (difference_type n) const {
	555	return (this + n);
	556	}
	557
	558	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	559	BOOST_UBLAS_INLINE
	560	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	561	typename self_type::
	562	#endif
	563	iterator2 begin () const {
	564	return (*this) ().find2 (1, it1_, 0);
	565	}
	566	BOOST_UBLAS_INLINE
	567	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	568	typename self_type::
	569	#endif
	570	iterator2 end () const {
	571	return (this) ().find2 (1, it1_, (this) ().size2 ());
	572	}
	573	BOOST_UBLAS_INLINE
	574	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	575	typename self_type::
	576	#endif
	577	reverse_iterator2 rbegin () const {
	578	return reverse_iterator2 (end ());
	579	}
	580	BOOST_UBLAS_INLINE
	581	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	582	typename self_type::
	583	#endif
	584	reverse_iterator2 rend () const {
	585	return reverse_iterator2 (begin ());
	586	}
	587	#endif
	588
	589	// Indices
	590	BOOST_UBLAS_INLINE
	591	size_type index1 () const {
	592	return it1_;
	593	}
	594	BOOST_UBLAS_INLINE
	595	size_type index2 () const {
	596	return it2_;
	597	}
	598
	599	// Assignment
	600	BOOST_UBLAS_INLINE
	601	iterator1 &operator = (const iterator1 &it) {
	602	container_reference<self_type>::assign (&it ());
	603	it1_ = it.it1_;
	604	it2_ = it.it2_;
	605	return *this;
	606	}
	607
	608	// Comparison
	609	BOOST_UBLAS_INLINE
	610	bool operator == (const iterator1 &it) const {
	611	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	612	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
	613	return it1_ == it.it1_;
	614	}
	615	BOOST_UBLAS_INLINE
	616	bool operator < (const iterator1 &it) const {
	617	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	618	BOOST_UBLAS_CHECK (it2_ == it.it2_, external_logic ());
	619	return it1_ < it.it1_;
	620	}
	621
	622	private:
	623	size_type it1_;
	624	size_type it2_;
	625
	626	friend class const_iterator1;
	627	};
	628	#endif
	629
	630	BOOST_UBLAS_INLINE
	631	iterator1 begin1 () {
	632	return find1 (0, 0, 0);
	633	}
	634	BOOST_UBLAS_INLINE
	635	iterator1 end1 () {
	636	return find1 (0, size1_, 0);
	637	}
	638
	639	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	640	class const_iterator2:
	641	public container_const_reference<banded_matrix>,
	642	public random_access_iterator_base<packed_random_access_iterator_tag,
	643	const_iterator2, value_type> {
	644	public:
	645	typedef typename banded_matrix::value_type value_type;
	646	typedef typename banded_matrix::difference_type difference_type;
	647	typedef typename banded_matrix::const_reference reference;
	648	typedef const typename banded_matrix::pointer pointer;
	649
	650	typedef const_iterator1 dual_iterator_type;
	651	typedef const_reverse_iterator1 dual_reverse_iterator_type;
	652
	653	// Construction and destruction
	654	BOOST_UBLAS_INLINE
	655	const_iterator2 ():
	656	container_const_reference<self_type> (), it1_ (), it2_ () {}
	657	BOOST_UBLAS_INLINE
	658	const_iterator2 (const self_type &m, size_type it1, size_type it2):
	659	container_const_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
	660	BOOST_UBLAS_INLINE
	661	const_iterator2 (const iterator2 &it):
	662	container_const_reference<self_type> (it ()), it1_ (it.it1_), it2_ (it.it2_) {}
	663
	664	// Arithmetic
	665	BOOST_UBLAS_INLINE
	666	const_iterator2 &operator ++ () {
	667	++ it2_;
	668	return *this;
	669	}
	670	BOOST_UBLAS_INLINE
	671	const_iterator2 &operator -- () {
	672	-- it2_;
	673	return *this;
	674	}
	675	BOOST_UBLAS_INLINE
	676	const_iterator2 &operator += (difference_type n) {
	677	it2_ += n;
	678	return *this;
	679	}
	680	BOOST_UBLAS_INLINE
	681	const_iterator2 &operator -= (difference_type n) {
	682	it2_ -= n;
	683	return *this;
	684	}
	685	BOOST_UBLAS_INLINE
	686	difference_type operator - (const const_iterator2 &it) const {
	687	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	688	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
	689	return it2_ - it.it2_;
	690	}
	691
	692	// Dereference
	693	BOOST_UBLAS_INLINE
	694	const_reference operator * () const {
	695	return (*this) () (it1_, it2_);
	696	}
	697	BOOST_UBLAS_INLINE
	698	const_reference operator [] (difference_type n) const {
	699	return (this + n);
	700	}
	701
	702	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	703	BOOST_UBLAS_INLINE
	704	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	705	typename self_type::
	706	#endif
	707	const_iterator1 begin () const {
	708	return (*this) ().find1 (1, 0, it2_);
	709	}
	710	BOOST_UBLAS_INLINE
	711	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	712	typename self_type::
	713	#endif
	714	const_iterator1 end () const {
	715	return (this) ().find1 (1, (this) ().size1 (), it2_);
	716	}
	717	BOOST_UBLAS_INLINE
	718	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	719	typename self_type::
	720	#endif
	721	const_reverse_iterator1 rbegin () const {
	722	return const_reverse_iterator1 (end ());
	723	}
	724	BOOST_UBLAS_INLINE
	725	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	726	typename self_type::
	727	#endif
	728	const_reverse_iterator1 rend () const {
	729	return const_reverse_iterator1 (begin ());
	730	}
	731	#endif
	732
	733	// Indices
	734	BOOST_UBLAS_INLINE
	735	size_type index1 () const {
	736	return it1_;
	737	}
	738	BOOST_UBLAS_INLINE
	739	size_type index2 () const {
	740	return it2_;
	741	}
	742
	743	// Assignment
	744	BOOST_UBLAS_INLINE
	745	const_iterator2 &operator = (const const_iterator2 &it) {
	746	container_const_reference<self_type>::assign (&it ());
	747	it1_ = it.it1_;
	748	it2_ = it.it2_;
	749	return *this;
	750	}
	751
	752	// Comparison
	753	BOOST_UBLAS_INLINE
	754	bool operator == (const const_iterator2 &it) const {
	755	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	756	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
	757	return it2_ == it.it2_;
	758	}
	759	BOOST_UBLAS_INLINE
	760	bool operator < (const const_iterator2 &it) const {
	761	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	762	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
	763	return it2_ < it.it2_;
	764	}
	765
	766	private:
	767	size_type it1_;
	768	size_type it2_;
	769	};
	770	#endif
	771
	772	BOOST_UBLAS_INLINE
	773	const_iterator2 begin2 () const {
	774	return find2 (0, 0, 0);
	775	}
	776	BOOST_UBLAS_INLINE
	777	const_iterator2 end2 () const {
	778	return find2 (0, 0, size2_);
	779	}
	780
	781	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	782	class iterator2:
	783	public container_reference<banded_matrix>,
	784	public random_access_iterator_base<packed_random_access_iterator_tag,
	785	iterator2, value_type> {
	786	public:
	787	typedef typename banded_matrix::value_type value_type;
	788	typedef typename banded_matrix::difference_type difference_type;
	789	typedef typename banded_matrix::reference reference;
	790	typedef typename banded_matrix::pointer pointer;
	791
	792	typedef iterator1 dual_iterator_type;
	793	typedef reverse_iterator1 dual_reverse_iterator_type;
	794
	795	// Construction and destruction
	796	BOOST_UBLAS_INLINE
	797	iterator2 ():
	798	container_reference<self_type> (), it1_ (), it2_ () {}
	799	BOOST_UBLAS_INLINE
	800	iterator2 (self_type &m, size_type it1, size_type it2):
	801	container_reference<self_type> (m), it1_ (it1), it2_ (it2) {}
	802
	803	// Arithmetic
	804	BOOST_UBLAS_INLINE
	805	iterator2 &operator ++ () {
	806	++ it2_;
	807	return *this;
	808	}
	809	BOOST_UBLAS_INLINE
	810	iterator2 &operator -- () {
	811	-- it2_;
	812	return *this;
	813	}
	814	BOOST_UBLAS_INLINE
	815	iterator2 &operator += (difference_type n) {
	816	it2_ += n;
	817	return *this;
	818	}
	819	BOOST_UBLAS_INLINE
	820	iterator2 &operator -= (difference_type n) {
	821	it2_ -= n;
	822	return *this;
	823	}
	824	BOOST_UBLAS_INLINE
	825	difference_type operator - (const iterator2 &it) const {
	826	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	827	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
	828	return it2_ - it.it2_;
	829	}
	830
	831	// Dereference
	832	BOOST_UBLAS_INLINE
	833	reference operator * () const {
	834	return (*this) ().at_element (it1_, it2_);
	835	}
	836	BOOST_UBLAS_INLINE
	837	reference operator [] (difference_type n) const {
	838	return (this + n);
	839	}
	840
	841	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	842	BOOST_UBLAS_INLINE
	843	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	844	typename self_type::
	845	#endif
	846	iterator1 begin () const {
	847	return (*this) ().find1 (1, 0, it2_);
	848	}
	849	BOOST_UBLAS_INLINE
	850	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	851	typename self_type::
	852	#endif
	853	iterator1 end () const {
	854	return (this) ().find1 (1, (this) ().size1 (), it2_);
	855	}
	856	BOOST_UBLAS_INLINE
	857	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	858	typename self_type::
	859	#endif
	860	reverse_iterator1 rbegin () const {
	861	return reverse_iterator1 (end ());
	862	}
	863	BOOST_UBLAS_INLINE
	864	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	865	typename self_type::
	866	#endif
	867	reverse_iterator1 rend () const {
	868	return reverse_iterator1 (begin ());
	869	}
	870	#endif
	871
	872	// Indices
	873	BOOST_UBLAS_INLINE
	874	size_type index1 () const {
	875	return it1_;
	876	}
	877	BOOST_UBLAS_INLINE
	878	size_type index2 () const {
	879	return it2_;
	880	}
	881
	882	// Assignment
	883	BOOST_UBLAS_INLINE
	884	iterator2 &operator = (const iterator2 &it) {
	885	container_reference<self_type>::assign (&it ());
	886	it1_ = it.it1_;
	887	it2_ = it.it2_;
	888	return *this;
	889	}
	890
	891	// Comparison
	892	BOOST_UBLAS_INLINE
	893	bool operator == (const iterator2 &it) const {
	894	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	895	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
	896	return it2_ == it.it2_;
	897	}
	898	BOOST_UBLAS_INLINE
	899	bool operator < (const iterator2 &it) const {
	900	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	901	BOOST_UBLAS_CHECK (it1_ == it.it1_, external_logic ());
	902	return it2_ < it.it2_;
	903	}
	904
	905	private:
	906	size_type it1_;
	907	size_type it2_;
	908
	909	friend class const_iterator2;
	910	};
	911	#endif
	912
	913	BOOST_UBLAS_INLINE
	914	iterator2 begin2 () {
	915	return find2 (0, 0, 0);
	916	}
	917	BOOST_UBLAS_INLINE
	918	iterator2 end2 () {
	919	return find2 (0, 0, size2_);
	920	}
	921
	922	// Reverse iterators
	923
	924	BOOST_UBLAS_INLINE
	925	const_reverse_iterator1 rbegin1 () const {
	926	return const_reverse_iterator1 (end1 ());
	927	}
	928	BOOST_UBLAS_INLINE
	929	const_reverse_iterator1 rend1 () const {
	930	return const_reverse_iterator1 (begin1 ());
	931	}
	932
	933	BOOST_UBLAS_INLINE
	934	reverse_iterator1 rbegin1 () {
	935	return reverse_iterator1 (end1 ());
	936	}
	937	BOOST_UBLAS_INLINE
	938	reverse_iterator1 rend1 () {
	939	return reverse_iterator1 (begin1 ());
	940	}
	941
	942	BOOST_UBLAS_INLINE
	943	const_reverse_iterator2 rbegin2 () const {
	944	return const_reverse_iterator2 (end2 ());
	945	}
	946	BOOST_UBLAS_INLINE
	947	const_reverse_iterator2 rend2 () const {
	948	return const_reverse_iterator2 (begin2 ());
	949	}
	950
	951	BOOST_UBLAS_INLINE
	952	reverse_iterator2 rbegin2 () {
	953	return reverse_iterator2 (end2 ());
	954	}
	955	BOOST_UBLAS_INLINE
	956	reverse_iterator2 rend2 () {
	957	return reverse_iterator2 (begin2 ());
	958	}
	959
	960	private:
	961	size_type size1_;
	962	size_type size2_;
	963	size_type lower_;
	964	size_type upper_;
	965	array_type data_;
	966	typedef const value_type const_value_type;
	967	static const_value_type zero_;
	968	};
	969
	970	template<class T, class L, class A>
	971	typename banded_matrix<T, L, A>::const_value_type banded_matrix<T, L, A>::zero_ = value_type/zero/();
	972
	973
	974	// Diagonal matrix class
	975	template<class T, class L, class A>
	976	class diagonal_matrix:
	977	public banded_matrix<T, L, A> {
	978	public:
	979	typedef typename A::size_type size_type;
	980	typedef banded_matrix<T, L, A> matrix_type;
	981	typedef A array_type;
	982
	983	// Construction and destruction
	984	BOOST_UBLAS_INLINE
	985	diagonal_matrix ():
	986	matrix_type () {}
	987	BOOST_UBLAS_INLINE
	988	diagonal_matrix (size_type size):
	989	matrix_type (size, size) {}
	990	BOOST_UBLAS_INLINE
	991	diagonal_matrix (size_type size, const array_type& data):
	992	matrix_type (size, size, 0, 0, data) {}
	993	BOOST_UBLAS_INLINE
	994	diagonal_matrix (size_type size1, size_type size2):
	995	matrix_type (size1, size2) {}
	996	template<class AE>
	997	BOOST_UBLAS_INLINE
	998	diagonal_matrix (const matrix_expression<AE> &ae):
	999	matrix_type (ae) {}
	1000	BOOST_UBLAS_INLINE
	1001	~diagonal_matrix () {}
	1002
	1003	// Assignment
	1004	BOOST_UBLAS_INLINE
	1005	diagonal_matrix &operator = (const diagonal_matrix &m) {
	1006	matrix_type::operator = (m);
	1007	return *this;
	1008	}
	1009	template<class AE>
	1010	BOOST_UBLAS_INLINE
	1011	diagonal_matrix &operator = (const matrix_expression<AE> &ae) {
	1012	matrix_type::operator = (ae);
	1013	return *this;
	1014	}
	1015	};
	1016
	1017	// Banded matrix adaptor class
	1018	template<class M>
	1019	class banded_adaptor:
	1020	public matrix_expression<banded_adaptor<M> > {
	1021
	1022	typedef banded_adaptor<M> self_type;
	1023	public:
	1024	#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
	1025	using matrix_expression<self_type>::operator ();
	1026	#endif
	1027	typedef const M const_matrix_type;
	1028	typedef M matrix_type;
	1029	typedef typename M::size_type size_type;
	1030	typedef typename M::difference_type difference_type;
	1031	typedef typename M::value_type value_type;
	1032	typedef typename M::const_reference const_reference;
	1033	typedef typename boost::mpl::if_<boost::is_const<M>,
	1034	typename M::const_reference,
	1035	typename M::reference>::type reference;
	1036	typedef typename boost::mpl::if_<boost::is_const<M>,
	1037	typename M::const_closure_type,
	1038	typename M::closure_type>::type matrix_closure_type;
	1039	typedef const self_type const_closure_type;
	1040	typedef self_type closure_type;
	1041	// Replaced by _temporary_traits to avoid type requirements on M
	1042	//typedef typename M::vector_temporary_type vector_temporary_type;
	1043	//typedef typename M::matrix_temporary_type matrix_temporary_type;
	1044	typedef typename storage_restrict_traits<typename M::storage_category,
	1045	packed_proxy_tag>::storage_category storage_category;
	1046	typedef typename M::orientation_category orientation_category;
	1047
	1048	// Construction and destruction
	1049	BOOST_UBLAS_INLINE
	1050	banded_adaptor (matrix_type &data, size_type lower = 0, size_type upper = 0):
	1051	matrix_expression<self_type> (),
	1052	data_ (data), lower_ (lower), upper_ (upper) {}
	1053	BOOST_UBLAS_INLINE
	1054	banded_adaptor (const banded_adaptor &m):
	1055	matrix_expression<self_type> (),
	1056	data_ (m.data_), lower_ (m.lower_), upper_ (m.upper_) {}
	1057
	1058	// Accessors
	1059	BOOST_UBLAS_INLINE
	1060	size_type size1 () const {
	1061	return data_.size1 ();
	1062	}
	1063	BOOST_UBLAS_INLINE
	1064	size_type size2 () const {
	1065	return data_.size2 ();
	1066	}
	1067	BOOST_UBLAS_INLINE
	1068	size_type lower () const {
	1069	return lower_;
	1070	}
	1071	BOOST_UBLAS_INLINE
	1072	size_type upper () const {
	1073	return upper_;
	1074	}
	1075
	1076	// Storage accessors
	1077	BOOST_UBLAS_INLINE
	1078	const matrix_closure_type &data () const {
	1079	return data_;
	1080	}
	1081	BOOST_UBLAS_INLINE
	1082	matrix_closure_type &data () {
	1083	return data_;
	1084	}
	1085
	1086	// Element access
	1087	#ifndef BOOST_UBLAS_PROXY_CONST_MEMBER
	1088	BOOST_UBLAS_INLINE
	1089	const_reference operator () (size_type i, size_type j) const {
	1090	BOOST_UBLAS_CHECK (i < size1 (), bad_index ());
	1091	BOOST_UBLAS_CHECK (j < size2 (), bad_index ());
	1092	#ifdef BOOST_UBLAS_OWN_BANDED
	1093	size_type k = (std::max) (i, j);
	1094	size_type l = lower_ + j - i;
	1095	if (k < (std::max) (size1 (), size2 ()) &&
	1096	l < lower_ + 1 + upper_)
	1097	return data () (i, j);
	1098	#else
	1099	size_type k = j;
	1100	size_type l = upper_ + i - j;
	1101	if (k < size2 () &&
	1102	l < lower_ + 1 + upper_)
	1103	return data () (i, j);
	1104	#endif
	1105	return zero_;
	1106	}
	1107	BOOST_UBLAS_INLINE
	1108	reference operator () (size_type i, size_type j) {
	1109	BOOST_UBLAS_CHECK (i < size1 (), bad_index ());
	1110	BOOST_UBLAS_CHECK (j < size2 (), bad_index ());
	1111	#ifdef BOOST_UBLAS_OWN_BANDED
	1112	size_type k = (std::max) (i, j);
	1113	size_type l = lower_ + j - i;
	1114	if (k < (std::max) (size1 (), size2 ()) &&
	1115	l < lower_ + 1 + upper_)
	1116	return data () (i, j);
	1117	#else
	1118	size_type k = j;
	1119	size_type l = upper_ + i - j;
	1120	if (k < size2 () &&
	1121	l < lower_ + 1 + upper_)
	1122	return data () (i, j);
	1123	#endif
	1124	#ifndef BOOST_UBLAS_REFERENCE_CONST_MEMBER
	1125	bad_index ().raise ();
	1126	#endif
	1127	return const_cast<reference>(zero_);
	1128	}
	1129	#else
	1130	BOOST_UBLAS_INLINE
	1131	reference operator () (size_type i, size_type j) const {
	1132	BOOST_UBLAS_CHECK (i < size1 (), bad_index ());
	1133	BOOST_UBLAS_CHECK (j < size2 (), bad_index ());
	1134	#ifdef BOOST_UBLAS_OWN_BANDED
	1135	size_type k = (std::max) (i, j);
	1136	size_type l = lower_ + j - i;
	1137	if (k < (std::max) (size1 (), size2 ()) &&
	1138	l < lower_ + 1 + upper_)
	1139	return data () (i, j);
	1140	#else
	1141	size_type k = j;
	1142	size_type l = upper_ + i - j;
	1143	if (k < size2 () &&
	1144	l < lower_ + 1 + upper_)
	1145	return data () (i, j);
	1146	#endif
	1147	#ifndef BOOST_UBLAS_REFERENCE_CONST_MEMBER
	1148	bad_index ().raise ();
	1149	#endif
	1150	return const_cast<reference>(zero_);
	1151	}
	1152	#endif
	1153
	1154	// Assignment
	1155	BOOST_UBLAS_INLINE
	1156	banded_adaptor &operator = (const banded_adaptor &m) {
	1157	matrix_assign<scalar_assign> (*this, m);
	1158	return *this;
	1159	}
	1160	BOOST_UBLAS_INLINE
	1161	banded_adaptor &assign_temporary (banded_adaptor &m) {
	1162	*this = m;
	1163	return *this;
	1164	}
	1165	template<class AE>
	1166	BOOST_UBLAS_INLINE
	1167	banded_adaptor &operator = (const matrix_expression<AE> &ae) {
	1168	matrix_assign<scalar_assign> (*this, matrix<value_type> (ae));
	1169	return *this;
	1170	}
	1171	template<class AE>
	1172	BOOST_UBLAS_INLINE
	1173	banded_adaptor &assign (const matrix_expression<AE> &ae) {
	1174	matrix_assign<scalar_assign> (*this, ae);
	1175	return *this;
	1176	}
	1177	template<class AE>
	1178	BOOST_UBLAS_INLINE
	1179	banded_adaptor& operator += (const matrix_expression<AE> &ae) {
	1180	matrix_assign<scalar_assign> (this, matrix<value_type> (this + ae));
	1181	return *this;
	1182	}
	1183	template<class AE>
	1184	BOOST_UBLAS_INLINE
	1185	banded_adaptor &plus_assign (const matrix_expression<AE> &ae) {
	1186	matrix_assign<scalar_plus_assign> (*this, ae);
	1187	return *this;
	1188	}
	1189	template<class AE>
	1190	BOOST_UBLAS_INLINE
	1191	banded_adaptor& operator -= (const matrix_expression<AE> &ae) {
	1192	matrix_assign<scalar_assign> (this, matrix<value_type> (this - ae));
	1193	return *this;
	1194	}
	1195	template<class AE>
	1196	BOOST_UBLAS_INLINE
	1197	banded_adaptor &minus_assign (const matrix_expression<AE> &ae) {
	1198	matrix_assign<scalar_minus_assign> (*this, ae);
	1199	return *this;
	1200	}
	1201	template<class AT>
	1202	BOOST_UBLAS_INLINE
	1203	banded_adaptor& operator *= (const AT &at) {
	1204	matrix_assign_scalar<scalar_multiplies_assign> (*this, at);
	1205	return *this;
	1206	}
	1207	template<class AT>
	1208	BOOST_UBLAS_INLINE
	1209	banded_adaptor& operator /= (const AT &at) {
	1210	matrix_assign_scalar<scalar_divides_assign> (*this, at);
	1211	return *this;
	1212	}
	1213
	1214	// Closure comparison
	1215	BOOST_UBLAS_INLINE
	1216	bool same_closure (const banded_adaptor &ba) const {
	1217	return (*this).data ().same_closure (ba.data ());
	1218	}
	1219
	1220	// Swapping
	1221	BOOST_UBLAS_INLINE
	1222	void swap (banded_adaptor &m) {
	1223	if (this != &m) {
	1224	BOOST_UBLAS_CHECK (lower_ == m.lower_, bad_size ());
	1225	BOOST_UBLAS_CHECK (upper_ == m.upper_, bad_size ());
	1226	matrix_swap<scalar_swap> (*this, m);
	1227	}
	1228	}
	1229	BOOST_UBLAS_INLINE
	1230	friend void swap (banded_adaptor &m1, banded_adaptor &m2) {
	1231	m1.swap (m2);
	1232	}
	1233
	1234	// Iterator types
	1235	private:
	1236	// Use the matrix iterator
	1237	typedef typename M::const_iterator1 const_subiterator1_type;
	1238	typedef typename boost::mpl::if_<boost::is_const<M>,
	1239	typename M::const_iterator1,
	1240	typename M::iterator1>::type subiterator1_type;
	1241	typedef typename M::const_iterator2 const_subiterator2_type;
	1242	typedef typename boost::mpl::if_<boost::is_const<M>,
	1243	typename M::const_iterator2,
	1244	typename M::iterator2>::type subiterator2_type;
	1245
	1246	public:
	1247	#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
	1248	typedef indexed_iterator1<self_type, packed_random_access_iterator_tag> iterator1;
	1249	typedef indexed_iterator2<self_type, packed_random_access_iterator_tag> iterator2;
	1250	typedef indexed_const_iterator1<self_type, packed_random_access_iterator_tag> const_iterator1;
	1251	typedef indexed_const_iterator2<self_type, packed_random_access_iterator_tag> const_iterator2;
	1252	#else
	1253	class const_iterator1;
	1254	class iterator1;
	1255	class const_iterator2;
	1256	class iterator2;
	1257	#endif
	1258	typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
	1259	typedef reverse_iterator_base1<iterator1> reverse_iterator1;
	1260	typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
	1261	typedef reverse_iterator_base2<iterator2> reverse_iterator2;
	1262
	1263	// Element lookup
	1264	BOOST_UBLAS_INLINE
	1265	const_iterator1 find1 (int rank, size_type i, size_type j) const {
	1266	if (rank == 1) {
	1267	size_type lower_i = (std::max) (difference_type (j - upper_), difference_type (0));
	1268	i = (std::max) (i, lower_i);
	1269	size_type upper_i = (std::min) (j + 1 + lower_, size1 ());
	1270	i = (std::min) (i, upper_i);
	1271	}
	1272	return const_iterator1 (*this, data ().find1 (rank, i, j));
	1273	}
	1274	BOOST_UBLAS_INLINE
	1275	iterator1 find1 (int rank, size_type i, size_type j) {
	1276	if (rank == 1) {
	1277	size_type lower_i = (std::max) (difference_type (j - upper_), difference_type (0));
	1278	i = (std::max) (i, lower_i);
	1279	size_type upper_i = (std::min) (j + 1 + lower_, size1 ());
	1280	i = (std::min) (i, upper_i);
	1281	}
	1282	return iterator1 (*this, data ().find1 (rank, i, j));
	1283	}
	1284	BOOST_UBLAS_INLINE
	1285	const_iterator2 find2 (int rank, size_type i, size_type j) const {
	1286	if (rank == 1) {
	1287	size_type lower_j = (std::max) (difference_type (i - lower_), difference_type (0));
	1288	j = (std::max) (j, lower_j);
	1289	size_type upper_j = (std::min) (i + 1 + upper_, size2 ());
	1290	j = (std::min) (j, upper_j);
	1291	}
	1292	return const_iterator2 (*this, data ().find2 (rank, i, j));
	1293	}
	1294	BOOST_UBLAS_INLINE
	1295	iterator2 find2 (int rank, size_type i, size_type j) {
	1296	if (rank == 1) {
	1297	size_type lower_j = (std::max) (difference_type (i - lower_), difference_type (0));
	1298	j = (std::max) (j, lower_j);
	1299	size_type upper_j = (std::min) (i + 1 + upper_, size2 ());
	1300	j = (std::min) (j, upper_j);
	1301	}
	1302	return iterator2 (*this, data ().find2 (rank, i, j));
	1303	}
	1304
	1305	// Iterators simply are indices.
	1306
	1307	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	1308	class const_iterator1:
	1309	public container_const_reference<banded_adaptor>,
	1310	public random_access_iterator_base<typename iterator_restrict_traits<
	1311	typename const_subiterator1_type::iterator_category, packed_random_access_iterator_tag>::iterator_category,
	1312	const_iterator1, value_type> {
	1313	public:
	1314	typedef typename const_subiterator1_type::value_type value_type;
	1315	typedef typename const_subiterator1_type::difference_type difference_type;
	1316	typedef typename const_subiterator1_type::reference reference;
	1317	typedef typename const_subiterator1_type::pointer pointer;
	1318
	1319	typedef const_iterator2 dual_iterator_type;
	1320	typedef const_reverse_iterator2 dual_reverse_iterator_type;
	1321
	1322	// Construction and destruction
	1323	BOOST_UBLAS_INLINE
	1324	const_iterator1 ():
	1325	container_const_reference<self_type> (), it1_ () {}
	1326	BOOST_UBLAS_INLINE
	1327	const_iterator1 (const self_type &m, const const_subiterator1_type &it1):
	1328	container_const_reference<self_type> (m), it1_ (it1) {}
	1329	BOOST_UBLAS_INLINE
	1330	const_iterator1 (const iterator1 &it):
	1331	container_const_reference<self_type> (it ()), it1_ (it.it1_) {}
	1332
	1333	// Arithmetic
	1334	BOOST_UBLAS_INLINE
	1335	const_iterator1 &operator ++ () {
	1336	++ it1_;
	1337	return *this;
	1338	}
	1339	BOOST_UBLAS_INLINE
	1340	const_iterator1 &operator -- () {
	1341	-- it1_;
	1342	return *this;
	1343	}
	1344	BOOST_UBLAS_INLINE
	1345	const_iterator1 &operator += (difference_type n) {
	1346	it1_ += n;
	1347	return *this;
	1348	}
	1349	BOOST_UBLAS_INLINE
	1350	const_iterator1 &operator -= (difference_type n) {
	1351	it1_ -= n;
	1352	return *this;
	1353	}
	1354	BOOST_UBLAS_INLINE
	1355	difference_type operator - (const const_iterator1 &it) const {
	1356	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1357	return it1_ - it.it1_;
	1358	}
	1359
	1360	// Dereference
	1361	BOOST_UBLAS_INLINE
	1362	const_reference operator * () const {
	1363	size_type i = index1 ();
	1364	size_type j = index2 ();
	1365	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
	1366	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
	1367	#ifdef BOOST_UBLAS_OWN_BANDED
	1368	size_type k = (std::max) (i, j);
	1369	size_type l = (*this) ().lower () + j - i;
	1370	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
	1371	l < (this) ().lower () + 1 + (this) ().upper ())
	1372	return *it1_;
	1373	#else
	1374	size_type k = j;
	1375	size_type l = (*this) ().upper () + i - j;
	1376	if (k < (*this) ().size2 () &&
	1377	l < (this) ().lower () + 1 + (this) ().upper ())
	1378	return *it1_;
	1379	#endif
	1380	return (*this) () (i, j);
	1381	}
	1382	BOOST_UBLAS_INLINE
	1383	const_reference operator [] (difference_type n) const {
	1384	return (this + n);
	1385	}
	1386
	1387	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	1388	BOOST_UBLAS_INLINE
	1389	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1390	typename self_type::
	1391	#endif
	1392	const_iterator2 begin () const {
	1393	return (*this) ().find2 (1, index1 (), 0);
	1394	}
	1395	BOOST_UBLAS_INLINE
	1396	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1397	typename self_type::
	1398	#endif
	1399	const_iterator2 end () const {
	1400	return (this) ().find2 (1, index1 (), (this) ().size2 ());
	1401	}
	1402	BOOST_UBLAS_INLINE
	1403	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1404	typename self_type::
	1405	#endif
	1406	const_reverse_iterator2 rbegin () const {
	1407	return const_reverse_iterator2 (end ());
	1408	}
	1409	BOOST_UBLAS_INLINE
	1410	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1411	typename self_type::
	1412	#endif
	1413	const_reverse_iterator2 rend () const {
	1414	return const_reverse_iterator2 (begin ());
	1415	}
	1416	#endif
	1417
	1418	// Indices
	1419	BOOST_UBLAS_INLINE
	1420	size_type index1 () const {
	1421	return it1_.index1 ();
	1422	}
	1423	BOOST_UBLAS_INLINE
	1424	size_type index2 () const {
	1425	return it1_.index2 ();
	1426	}
	1427
	1428	// Assignment
	1429	BOOST_UBLAS_INLINE
	1430	const_iterator1 &operator = (const const_iterator1 &it) {
	1431	container_const_reference<self_type>::assign (&it ());
	1432	it1_ = it.it1_;
	1433	return *this;
	1434	}
	1435
	1436	// Comparison
	1437	BOOST_UBLAS_INLINE
	1438	bool operator == (const const_iterator1 &it) const {
	1439	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1440	return it1_ == it.it1_;
	1441	}
	1442	BOOST_UBLAS_INLINE
	1443	bool operator < (const const_iterator1 &it) const {
	1444	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1445	return it1_ < it.it1_;
	1446	}
	1447
	1448	private:
	1449	const_subiterator1_type it1_;
	1450	};
	1451	#endif
	1452
	1453	BOOST_UBLAS_INLINE
	1454	const_iterator1 begin1 () const {
	1455	return find1 (0, 0, 0);
	1456	}
	1457	BOOST_UBLAS_INLINE
	1458	const_iterator1 end1 () const {
	1459	return find1 (0, size1 (), 0);
	1460	}
	1461
	1462	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	1463	class iterator1:
	1464	public container_reference<banded_adaptor>,
	1465	public random_access_iterator_base<typename iterator_restrict_traits<
	1466	typename subiterator1_type::iterator_category, packed_random_access_iterator_tag>::iterator_category,
	1467	iterator1, value_type> {
	1468	public:
	1469	typedef typename subiterator1_type::value_type value_type;
	1470	typedef typename subiterator1_type::difference_type difference_type;
	1471	typedef typename subiterator1_type::reference reference;
	1472	typedef typename subiterator1_type::pointer pointer;
	1473
	1474	typedef iterator2 dual_iterator_type;
	1475	typedef reverse_iterator2 dual_reverse_iterator_type;
	1476
	1477	// Construction and destruction
	1478	BOOST_UBLAS_INLINE
	1479	iterator1 ():
	1480	container_reference<self_type> (), it1_ () {}
	1481	BOOST_UBLAS_INLINE
	1482	iterator1 (self_type &m, const subiterator1_type &it1):
	1483	container_reference<self_type> (m), it1_ (it1) {}
	1484
	1485	// Arithmetic
	1486	BOOST_UBLAS_INLINE
	1487	iterator1 &operator ++ () {
	1488	++ it1_;
	1489	return *this;
	1490	}
	1491	BOOST_UBLAS_INLINE
	1492	iterator1 &operator -- () {
	1493	-- it1_;
	1494	return *this;
	1495	}
	1496	BOOST_UBLAS_INLINE
	1497	iterator1 &operator += (difference_type n) {
	1498	it1_ += n;
	1499	return *this;
	1500	}
	1501	BOOST_UBLAS_INLINE
	1502	iterator1 &operator -= (difference_type n) {
	1503	it1_ -= n;
	1504	return *this;
	1505	}
	1506	BOOST_UBLAS_INLINE
	1507	difference_type operator - (const iterator1 &it) const {
	1508	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1509	return it1_ - it.it1_;
	1510	}
	1511
	1512	// Dereference
	1513	BOOST_UBLAS_INLINE
	1514	reference operator * () const {
	1515	size_type i = index1 ();
	1516	size_type j = index2 ();
	1517	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
	1518	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
	1519	#ifdef BOOST_UBLAS_OWN_BANDED
	1520	size_type k = (std::max) (i, j);
	1521	size_type l = (*this) ().lower () + j - i;
	1522	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
	1523	l < (this) ().lower () + 1 + (this) ().upper ())
	1524	return *it1_;
	1525	#else
	1526	size_type k = j;
	1527	size_type l = (*this) ().upper () + i - j;
	1528	if (k < (*this) ().size2 () &&
	1529	l < (this) ().lower () + 1 + (this) ().upper ())
	1530	return *it1_;
	1531	#endif
	1532	return (*this) () (i, j);
	1533	}
	1534	BOOST_UBLAS_INLINE
	1535	reference operator [] (difference_type n) const {
	1536	return (this + n);
	1537	}
	1538
	1539	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	1540	BOOST_UBLAS_INLINE
	1541	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1542	typename self_type::
	1543	#endif
	1544	iterator2 begin () const {
	1545	return (*this) ().find2 (1, index1 (), 0);
	1546	}
	1547	BOOST_UBLAS_INLINE
	1548	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1549	typename self_type::
	1550	#endif
	1551	iterator2 end () const {
	1552	return (this) ().find2 (1, index1 (), (this) ().size2 ());
	1553	}
	1554	BOOST_UBLAS_INLINE
	1555	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1556	typename self_type::
	1557	#endif
	1558	reverse_iterator2 rbegin () const {
	1559	return reverse_iterator2 (end ());
	1560	}
	1561	BOOST_UBLAS_INLINE
	1562	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1563	typename self_type::
	1564	#endif
	1565	reverse_iterator2 rend () const {
	1566	return reverse_iterator2 (begin ());
	1567	}
	1568	#endif
	1569
	1570	// Indices
	1571	BOOST_UBLAS_INLINE
	1572	size_type index1 () const {
	1573	return it1_.index1 ();
	1574	}
	1575	BOOST_UBLAS_INLINE
	1576	size_type index2 () const {
	1577	return it1_.index2 ();
	1578	}
	1579
	1580	// Assignment
	1581	BOOST_UBLAS_INLINE
	1582	iterator1 &operator = (const iterator1 &it) {
	1583	container_reference<self_type>::assign (&it ());
	1584	it1_ = it.it1_;
	1585	return *this;
	1586	}
	1587
	1588	// Comparison
	1589	BOOST_UBLAS_INLINE
	1590	bool operator == (const iterator1 &it) const {
	1591	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1592	return it1_ == it.it1_;
	1593	}
	1594	BOOST_UBLAS_INLINE
	1595	bool operator < (const iterator1 &it) const {
	1596	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1597	return it1_ < it.it1_;
	1598	}
	1599
	1600	private:
	1601	subiterator1_type it1_;
	1602
	1603	friend class const_iterator1;
	1604	};
	1605	#endif
	1606
	1607	BOOST_UBLAS_INLINE
	1608	iterator1 begin1 () {
	1609	return find1 (0, 0, 0);
	1610	}
	1611	BOOST_UBLAS_INLINE
	1612	iterator1 end1 () {
	1613	return find1 (0, size1 (), 0);
	1614	}
	1615
	1616	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	1617	class const_iterator2:
	1618	public container_const_reference<banded_adaptor>,
	1619	public random_access_iterator_base<packed_random_access_iterator_tag,
	1620	const_iterator2, value_type> {
	1621	public:
	1622	typedef typename iterator_restrict_traits<typename const_subiterator2_type::iterator_category,
	1623	packed_random_access_iterator_tag>::iterator_category iterator_category;
	1624	typedef typename const_subiterator2_type::value_type value_type;
	1625	typedef typename const_subiterator2_type::difference_type difference_type;
	1626	typedef typename const_subiterator2_type::reference reference;
	1627	typedef typename const_subiterator2_type::pointer pointer;
	1628
	1629	typedef const_iterator1 dual_iterator_type;
	1630	typedef const_reverse_iterator1 dual_reverse_iterator_type;
	1631
	1632	// Construction and destruction
	1633	BOOST_UBLAS_INLINE
	1634	const_iterator2 ():
	1635	container_const_reference<self_type> (), it2_ () {}
	1636	BOOST_UBLAS_INLINE
	1637	const_iterator2 (const self_type &m, const const_subiterator2_type &it2):
	1638	container_const_reference<self_type> (m), it2_ (it2) {}
	1639	BOOST_UBLAS_INLINE
	1640	const_iterator2 (const iterator2 &it):
	1641	container_const_reference<self_type> (it ()), it2_ (it.it2_) {}
	1642
	1643	// Arithmetic
	1644	BOOST_UBLAS_INLINE
	1645	const_iterator2 &operator ++ () {
	1646	++ it2_;
	1647	return *this;
	1648	}
	1649	BOOST_UBLAS_INLINE
	1650	const_iterator2 &operator -- () {
	1651	-- it2_;
	1652	return *this;
	1653	}
	1654	BOOST_UBLAS_INLINE
	1655	const_iterator2 &operator += (difference_type n) {
	1656	it2_ += n;
	1657	return *this;
	1658	}
	1659	BOOST_UBLAS_INLINE
	1660	const_iterator2 &operator -= (difference_type n) {
	1661	it2_ -= n;
	1662	return *this;
	1663	}
	1664	BOOST_UBLAS_INLINE
	1665	difference_type operator - (const const_iterator2 &it) const {
	1666	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1667	return it2_ - it.it2_;
	1668	}
	1669
	1670	// Dereference
	1671	BOOST_UBLAS_INLINE
	1672	const_reference operator * () const {
	1673	size_type i = index1 ();
	1674	size_type j = index2 ();
	1675	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
	1676	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
	1677	#ifdef BOOST_UBLAS_OWN_BANDED
	1678	size_type k = (std::max) (i, j);
	1679	size_type l = (*this) ().lower () + j - i;
	1680	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
	1681	l < (this) ().lower () + 1 + (this) ().upper ())
	1682	return *it2_;
	1683	#else
	1684	size_type k = j;
	1685	size_type l = (*this) ().upper () + i - j;
	1686	if (k < (*this) ().size2 () &&
	1687	l < (this) ().lower () + 1 + (this) ().upper ())
	1688	return *it2_;
	1689	#endif
	1690	return (*this) () (i, j);
	1691	}
	1692	BOOST_UBLAS_INLINE
	1693	const_reference operator [] (difference_type n) const {
	1694	return (this + n);
	1695	}
	1696
	1697	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	1698	BOOST_UBLAS_INLINE
	1699	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1700	typename self_type::
	1701	#endif
	1702	const_iterator1 begin () const {
	1703	return (*this) ().find1 (1, 0, index2 ());
	1704	}
	1705	BOOST_UBLAS_INLINE
	1706	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1707	typename self_type::
	1708	#endif
	1709	const_iterator1 end () const {
	1710	return (this) ().find1 (1, (this) ().size1 (), index2 ());
	1711	}
	1712	BOOST_UBLAS_INLINE
	1713	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1714	typename self_type::
	1715	#endif
	1716	const_reverse_iterator1 rbegin () const {
	1717	return const_reverse_iterator1 (end ());
	1718	}
	1719	BOOST_UBLAS_INLINE
	1720	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1721	typename self_type::
	1722	#endif
	1723	const_reverse_iterator1 rend () const {
	1724	return const_reverse_iterator1 (begin ());
	1725	}
	1726	#endif
	1727
	1728	// Indices
	1729	BOOST_UBLAS_INLINE
	1730	size_type index1 () const {
	1731	return it2_.index1 ();
	1732	}
	1733	BOOST_UBLAS_INLINE
	1734	size_type index2 () const {
	1735	return it2_.index2 ();
	1736	}
	1737
	1738	// Assignment
	1739	BOOST_UBLAS_INLINE
	1740	const_iterator2 &operator = (const const_iterator2 &it) {
	1741	container_const_reference<self_type>::assign (&it ());
	1742	it2_ = it.it2_;
	1743	return *this;
	1744	}
	1745
	1746	// Comparison
	1747	BOOST_UBLAS_INLINE
	1748	bool operator == (const const_iterator2 &it) const {
	1749	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1750	return it2_ == it.it2_;
	1751	}
	1752	BOOST_UBLAS_INLINE
	1753	bool operator < (const const_iterator2 &it) const {
	1754	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1755	return it2_ < it.it2_;
	1756	}
	1757
	1758	private:
	1759	const_subiterator2_type it2_;
	1760	};
	1761	#endif
	1762
	1763	BOOST_UBLAS_INLINE
	1764	const_iterator2 begin2 () const {
	1765	return find2 (0, 0, 0);
	1766	}
	1767	BOOST_UBLAS_INLINE
	1768	const_iterator2 end2 () const {
	1769	return find2 (0, 0, size2 ());
	1770	}
	1771
	1772	#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
	1773	class iterator2:
	1774	public container_reference<banded_adaptor>,
	1775	public random_access_iterator_base<typename iterator_restrict_traits<
	1776	typename subiterator2_type::iterator_category, packed_random_access_iterator_tag>::iterator_category,
	1777	iterator2, value_type> {
	1778	public:
	1779	typedef typename subiterator2_type::value_type value_type;
	1780	typedef typename subiterator2_type::difference_type difference_type;
	1781	typedef typename subiterator2_type::reference reference;
	1782	typedef typename subiterator2_type::pointer pointer;
	1783
	1784	typedef iterator1 dual_iterator_type;
	1785	typedef reverse_iterator1 dual_reverse_iterator_type;
	1786
	1787	// Construction and destruction
	1788	BOOST_UBLAS_INLINE
	1789	iterator2 ():
	1790	container_reference<self_type> (), it2_ () {}
	1791	BOOST_UBLAS_INLINE
	1792	iterator2 (self_type &m, const subiterator2_type &it2):
	1793	container_reference<self_type> (m), it2_ (it2) {}
	1794
	1795	// Arithmetic
	1796	BOOST_UBLAS_INLINE
	1797	iterator2 &operator ++ () {
	1798	++ it2_;
	1799	return *this;
	1800	}
	1801	BOOST_UBLAS_INLINE
	1802	iterator2 &operator -- () {
	1803	-- it2_;
	1804	return *this;
	1805	}
	1806	BOOST_UBLAS_INLINE
	1807	iterator2 &operator += (difference_type n) {
	1808	it2_ += n;
	1809	return *this;
	1810	}
	1811	BOOST_UBLAS_INLINE
	1812	iterator2 &operator -= (difference_type n) {
	1813	it2_ -= n;
	1814	return *this;
	1815	}
	1816	BOOST_UBLAS_INLINE
	1817	difference_type operator - (const iterator2 &it) const {
	1818	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1819	return it2_ - it.it2_;
	1820	}
	1821
	1822	// Dereference
	1823	BOOST_UBLAS_INLINE
	1824	reference operator * () const {
	1825	size_type i = index1 ();
	1826	size_type j = index2 ();
	1827	BOOST_UBLAS_CHECK (i < (*this) ().size1 (), bad_index ());
	1828	BOOST_UBLAS_CHECK (j < (*this) ().size2 (), bad_index ());
	1829	#ifdef BOOST_UBLAS_OWN_BANDED
	1830	size_type k = (std::max) (i, j);
	1831	size_type l = (*this) ().lower () + j - i;
	1832	if (k < (std::max) ((this) ().size1 (), (this) ().size2 ()) &&
	1833	l < (this) ().lower () + 1 + (this) ().upper ())
	1834	return *it2_;
	1835	#else
	1836	size_type k = j;
	1837	size_type l = (*this) ().upper () + i - j;
	1838	if (k < (*this) ().size2 () &&
	1839	l < (this) ().lower () + 1 + (this) ().upper ())
	1840	return *it2_;
	1841	#endif
	1842	return (*this) () (i, j);
	1843	}
	1844	BOOST_UBLAS_INLINE
	1845	reference operator [] (difference_type n) const {
	1846	return (this + n);
	1847	}
	1848
	1849	#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
	1850	BOOST_UBLAS_INLINE
	1851	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1852	typename self_type::
	1853	#endif
	1854	iterator1 begin () const {
	1855	return (*this) ().find1 (1, 0, index2 ());
	1856	}
	1857	BOOST_UBLAS_INLINE
	1858	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1859	typename self_type::
	1860	#endif
	1861	iterator1 end () const {
	1862	return (this) ().find1 (1, (this) ().size1 (), index2 ());
	1863	}
	1864	BOOST_UBLAS_INLINE
	1865	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1866	typename self_type::
	1867	#endif
	1868	reverse_iterator1 rbegin () const {
	1869	return reverse_iterator1 (end ());
	1870	}
	1871	BOOST_UBLAS_INLINE
	1872	#ifdef BOOST_UBLAS_MSVC_NESTED_CLASS_RELATION
	1873	typename self_type::
	1874	#endif
	1875	reverse_iterator1 rend () const {
	1876	return reverse_iterator1 (begin ());
	1877	}
	1878	#endif
	1879
	1880	// Indices
	1881	BOOST_UBLAS_INLINE
	1882	size_type index1 () const {
	1883	return it2_.index1 ();
	1884	}
	1885	BOOST_UBLAS_INLINE
	1886	size_type index2 () const {
	1887	return it2_.index2 ();
	1888	}
	1889
	1890	// Assignment
	1891	BOOST_UBLAS_INLINE
	1892	iterator2 &operator = (const iterator2 &it) {
	1893	container_reference<self_type>::assign (&it ());
	1894	it2_ = it.it2_;
	1895	return *this;
	1896	}
	1897
	1898	// Comparison
	1899	BOOST_UBLAS_INLINE
	1900	bool operator == (const iterator2 &it) const {
	1901	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1902	return it2_ == it.it2_;
	1903	}
	1904	BOOST_UBLAS_INLINE
	1905	bool operator < (const iterator2 &it) const {
	1906	BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
	1907	return it2_ < it.it2_;
	1908	}
	1909
	1910	private:
	1911	subiterator2_type it2_;
	1912
	1913	friend class const_iterator2;
	1914	};
	1915	#endif
	1916
	1917	BOOST_UBLAS_INLINE
	1918	iterator2 begin2 () {
	1919	return find2 (0, 0, 0);
	1920	}
	1921	BOOST_UBLAS_INLINE
	1922	iterator2 end2 () {
	1923	return find2 (0, 0, size2 ());
	1924	}
	1925
	1926	// Reverse iterators
	1927
	1928	BOOST_UBLAS_INLINE
	1929	const_reverse_iterator1 rbegin1 () const {
	1930	return const_reverse_iterator1 (end1 ());
	1931	}
	1932	BOOST_UBLAS_INLINE
	1933	const_reverse_iterator1 rend1 () const {
	1934	return const_reverse_iterator1 (begin1 ());
	1935	}
	1936
	1937	BOOST_UBLAS_INLINE
	1938	reverse_iterator1 rbegin1 () {
	1939	return reverse_iterator1 (end1 ());
	1940	}
	1941	BOOST_UBLAS_INLINE
	1942	reverse_iterator1 rend1 () {
	1943	return reverse_iterator1 (begin1 ());
	1944	}
	1945
	1946	BOOST_UBLAS_INLINE
	1947	const_reverse_iterator2 rbegin2 () const {
	1948	return const_reverse_iterator2 (end2 ());
	1949	}
	1950	BOOST_UBLAS_INLINE
	1951	const_reverse_iterator2 rend2 () const {
	1952	return const_reverse_iterator2 (begin2 ());
	1953	}
	1954
	1955	BOOST_UBLAS_INLINE
	1956	reverse_iterator2 rbegin2 () {
	1957	return reverse_iterator2 (end2 ());
	1958	}
	1959	BOOST_UBLAS_INLINE
	1960	reverse_iterator2 rend2 () {
	1961	return reverse_iterator2 (begin2 ());
	1962	}
	1963
	1964	private:
	1965	matrix_closure_type data_;
	1966	size_type lower_;
	1967	size_type upper_;
	1968	typedef const value_type const_value_type;
	1969	static const_value_type zero_;
	1970	};
	1971
	1972	// Specialization for temporary_traits
	1973	template <class M>
	1974	struct vector_temporary_traits< banded_adaptor<M> >
	1975	: vector_temporary_traits< M > {} ;
	1976	template <class M>
	1977	struct vector_temporary_traits< const banded_adaptor<M> >
	1978	: vector_temporary_traits< M > {} ;
	1979
	1980	template <class M>
	1981	struct matrix_temporary_traits< banded_adaptor<M> >
	1982	: matrix_temporary_traits< M > {} ;
	1983	template <class M>
	1984	struct matrix_temporary_traits< const banded_adaptor<M> >
	1985	: matrix_temporary_traits< M > {} ;
	1986
	1987
	1988	template<class M>
	1989	typename banded_adaptor<M>::const_value_type banded_adaptor<M>::zero_ = value_type/zero/();
	1990
	1991	// Diagonal matrix adaptor class
	1992	template<class M>
	1993	class diagonal_adaptor:
	1994	public banded_adaptor<M> {
	1995	public:
	1996	typedef M matrix_type;
	1997	typedef banded_adaptor<M> adaptor_type;
	1998
	1999	// Construction and destruction
	2000	BOOST_UBLAS_INLINE
	2001	diagonal_adaptor ():
	2002	adaptor_type () {}
	2003	BOOST_UBLAS_INLINE
	2004	diagonal_adaptor (matrix_type &data):
	2005	adaptor_type (data) {}
	2006	BOOST_UBLAS_INLINE
	2007	~diagonal_adaptor () {}
	2008
	2009	// Assignment
	2010	BOOST_UBLAS_INLINE
	2011	diagonal_adaptor &operator = (const diagonal_adaptor &m) {
	2012	adaptor_type::operator = (m);
	2013	return *this;
	2014	}
	2015	template<class AE>
	2016	BOOST_UBLAS_INLINE
	2017	diagonal_adaptor &operator = (const matrix_expression<AE> &ae) {
	2018	adaptor_type::operator = (ae);
	2019	return *this;
	2020	}
	2021	};
	2022
	2023	}}}
	2024
	2025	#endif

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

Download in other formats: