Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/numeric/ublas/hermitian.hpp@bde4ae8d615e (annotated)

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

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--