Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/numeric/ublas/symmetric.hpp @ 20

Last change on this file since 20 was 12, checked in by landauf, 18 years ago
added boost
File size: 79.7 KB

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

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

Download in other formats: