Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/numeric/ublas/hermitian.hpp @ 12

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

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

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

Download in other formats: