Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 12 was 12, checked in by landauf, 18 years ago

added boost
File size: 83.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_CONCEPTS_
18#define _BOOST_UBLAS_CONCEPTS_
19
20#include <boost/concept_check.hpp>
21
22// Concept checks based on ideas of Jeremy Siek
23
24namespace boost { namespace numeric { namespace ublas {
25
26
27    template<class T>
28    struct AssignableConcept {
29        typedef T value_type;
30
31        static void constraints (value_type t) {
32            // Copy Constructor
33            value_type c1 (t);
34            value_type c2 = t;
35            // Assignment
36            value_type a = t;
37            std::swap (c1, c2);
38            ignore_unused_variable_warning (a);
39        }
40    };
41
42    template<class T>
43    struct EqualityComparableConcept {
44        typedef T value_type;
45
46        static void constraints (const value_type t) {
47            bool b;
48            // Equality
49            b = t == t;
50            // Inequality
51            b = t != t;
52            ignore_unused_variable_warning (b);
53        }
54    };
55
56    template<class T>
57    struct LessThanComparableConcept {
58        typedef T value_type;
59
60        static void constraints (const value_type t) {
61            bool b;
62            b = t < t;
63            b = t <= t;
64            b = t >= t;
65            b = t > t;
66            ignore_unused_variable_warning (b);
67        }
68    };
69
70    template<class T>
71    struct DefaultConstructibleConcept {
72        typedef T value_type;
73
74        static void constraints () {
75            // Default Constructor
76            static value_type c1 = value_type ();
77            static value_type c2;
78            ignore_unused_variable_warning (c1);
79            ignore_unused_variable_warning (c2);
80        }
81    };
82
83    template<class I, class T = typename std::iterator_traits<I>::value_type>
84    struct BidirectionalIteratorConcept {
85        typedef I iterator_type;
86       
87        typedef typename std::iterator_traits<I>::iterator_category iterator_category;
88        typedef typename std::iterator_traits<I>::difference_type difference_type;
89        typedef typename std::iterator_traits<I>::value_type value_type;
90        typedef typename std::iterator_traits<I>::reference reference;
91        typedef typename std::iterator_traits<I>::pointer pointer;
92
93        static void constraints () {
94            AssignableConcept<iterator_type>::constraints (iterator_type ());
95            EqualityComparableConcept<iterator_type>::constraints (iterator_type ());
96            DefaultConstructibleConcept<iterator_type>::constraints ();
97            iterator_type it = iterator_type ();
98
99            // Associated types - assume constructable
100            iterator_category c;
101            difference_type d (0);
102            pointer p (0);
103            // Dereference
104            reference r (*it);
105            value_type t (r);
106            // Member access
107            // FIXME it->m;
108            // Preincrement
109            ++ it;
110            // Postincrement
111            it ++;
112            // Predecrement
113            -- it;
114            // Postdecrement
115            it --;
116            ignore_unused_variable_warning (t);
117            ignore_unused_variable_warning (c);
118            ignore_unused_variable_warning (d);
119            ignore_unused_variable_warning (p);
120            ignore_unused_variable_warning (r);
121        }
122    };
123
124    template<class I, class T = typename std::iterator_traits<I>::value_type>
125    struct MutableBidirectionalIteratorConcept {
126        typedef I iterator_type;
127        typedef T value_type;
128
129        static void constraints () {
130            BidirectionalIteratorConcept<iterator_type, value_type>::constraints ();
131            iterator_type it = iterator_type ();
132            value_type t = value_type ();
133            // Dereference assignment
134            *it = t;
135            ignore_unused_variable_warning (t);
136        }
137    };
138
139    template<class I, class D = typename std::iterator_traits<I>::difference_type, class T = typename std::iterator_traits<I>::value_type>
140    struct RandomAccessIteratorConcept {
141        typedef I iterator_type;
142        typedef D difference_type;
143        typedef T value_type;
144
145        static void constraints () {
146            LessThanComparableConcept<iterator_type>::constraints (iterator_type ());
147            BidirectionalIteratorConcept<iterator_type, value_type>::constraints ();
148            iterator_type it = iterator_type (), it1 = iterator_type (), it2 = iterator_type ();
149            difference_type n (0);
150            value_type t;
151            // Forward motion
152            it += n;
153            // Iterator addition
154            it = it + n;
155            iterator_type itp (it + n);
156            // Backward motion
157            it -= n;
158            // Iterator subtraction
159            it = it - n;
160            iterator_type itm (it - n);
161            // Difference
162            n = it1 - it2;
163            // Element operator
164#ifdef BOOST_UBLAS_ITERATOR_IS_INDEXABLE
165            t = it [n];
166#endif
167            t = *(it + n);
168            ignore_unused_variable_warning (itp);
169            ignore_unused_variable_warning (itm);
170            ignore_unused_variable_warning (t);
171        }
172    };
173
174    template<class I, class D = typename std::iterator_traits<I>::difference_type, class T = typename std::iterator_traits<I>::value_type>
175    struct MutableRandomAccessIteratorConcept {
176        typedef I iterator_type;
177        typedef D difference_type;
178        typedef T value_type;
179
180        static void constraints () {
181            MutableBidirectionalIteratorConcept<iterator_type, value_type>::constraints ();
182            RandomAccessIteratorConcept<iterator_type, difference_type, value_type>::constraints ();
183            iterator_type it = iterator_type ();
184            difference_type n (0);
185            value_type t = value_type ();
186            // Element assignment
187#ifdef BOOST_UBLAS_ITERATOR_IS_INDEXABLE
188            it [n] = t;
189#endif
190            *(it + n) = t;
191        }
192    };
193
194    template<class I>
195    struct Indexed1DIteratorConcept {
196        typedef I iterator_type;
197
198        static void constraints () {
199            iterator_type it = iterator_type ();
200            // Index
201            it.index ();
202        }
203    };
204
205    template<class I>
206    struct IndexedBidirectional1DIteratorConcept {
207        typedef I iterator_type;
208
209        static void constraints () {
210            BidirectionalIteratorConcept<iterator_type>::constraints ();
211            Indexed1DIteratorConcept<iterator_type>::constraints ();
212        }
213    };
214
215    template<class I>
216    struct MutableIndexedBidirectional1DIteratorConcept {
217        typedef I iterator_type;
218
219        static void constraints () {
220            MutableBidirectionalIteratorConcept<iterator_type>::constraints ();
221            Indexed1DIteratorConcept<iterator_type>::constraints ();
222        }
223    };
224
225    template<class I>
226    struct IndexedRandomAccess1DIteratorConcept {
227        typedef I iterator_type;
228
229        static void constraints () {
230            RandomAccessIteratorConcept<iterator_type>::constraints ();
231            Indexed1DIteratorConcept<iterator_type>::constraints ();
232        }
233    };
234
235    template<class I>
236    struct MutableIndexedRandomAccess1DIteratorConcept {
237        typedef I iterator_type;
238
239        static void constraints () {
240            MutableRandomAccessIteratorConcept<iterator_type>::constraints ();
241            Indexed1DIteratorConcept<iterator_type>::constraints ();
242        }
243    };
244
245    template<class I>
246    struct Indexed2DIteratorConcept {
247        typedef I iterator_type;
248        typedef typename I::dual_iterator_type dual_iterator_type;
249        typedef typename I::dual_reverse_iterator_type dual_reverse_iterator_type;
250
251        static void constraints () {
252            iterator_type it = iterator_type ();
253            // Indices
254            it.index1 ();
255            it.index2 ();
256            // Iterator begin/end
257            dual_iterator_type it_begin (it.begin ());
258            dual_iterator_type it_end (it.end ());
259            // Reverse iterator begin/end
260            dual_reverse_iterator_type it_rbegin (it.rbegin ());
261            dual_reverse_iterator_type it_rend (it.rend ());
262            ignore_unused_variable_warning (it_begin);
263            ignore_unused_variable_warning (it_end);
264            ignore_unused_variable_warning (it_rbegin);
265            ignore_unused_variable_warning (it_rend);
266        }
267    };
268
269    template<class I1, class I2>
270    struct IndexedBidirectional2DIteratorConcept {
271        typedef I1 subiterator1_type;
272        typedef I2 subiterator2_type;
273
274        static void constraints () {
275            BidirectionalIteratorConcept<subiterator1_type>::constraints ();
276            BidirectionalIteratorConcept<subiterator2_type>::constraints ();
277            Indexed2DIteratorConcept<subiterator1_type>::constraints ();
278            Indexed2DIteratorConcept<subiterator2_type>::constraints ();
279        }
280    };
281
282    template<class I1, class I2>
283    struct MutableIndexedBidirectional2DIteratorConcept {
284        typedef I1 subiterator1_type;
285        typedef I2 subiterator2_type;
286
287        static void constraints () {
288            MutableBidirectionalIteratorConcept<subiterator1_type>::constraints ();
289            MutableBidirectionalIteratorConcept<subiterator2_type>::constraints ();
290            Indexed2DIteratorConcept<subiterator1_type>::constraints ();
291            Indexed2DIteratorConcept<subiterator2_type>::constraints ();
292        }
293    };
294
295    template<class I1, class I2>
296    struct IndexedRandomAccess2DIteratorConcept {
297        typedef I1 subiterator1_type;
298        typedef I2 subiterator2_type;
299
300        static void constraints () {
301            RandomAccessIteratorConcept<subiterator1_type>::constraints ();
302            RandomAccessIteratorConcept<subiterator2_type>::constraints ();
303            Indexed2DIteratorConcept<subiterator1_type>::constraints ();
304            Indexed2DIteratorConcept<subiterator2_type>::constraints ();
305        }
306    };
307
308    template<class I1, class I2>
309    struct MutableIndexedRandomAccess2DIteratorConcept {
310        typedef I1 subiterator1_type;
311        typedef I2 subiterator2_type;
312
313        static void constraints () {
314            MutableRandomAccessIteratorConcept<subiterator1_type>::constraints ();
315            MutableRandomAccessIteratorConcept<subiterator2_type>::constraints ();
316            Indexed2DIteratorConcept<subiterator1_type>::constraints ();
317            Indexed2DIteratorConcept<subiterator2_type>::constraints ();
318        }
319    };
320
321    template<class C>
322    struct ContainerConcept {
323        typedef C container_type;
324        typedef typename C::size_type size_type;
325        typedef typename C::const_iterator const_iterator_type;
326
327        static void constraints () {
328            DefaultConstructibleConcept<container_type>::constraints ();
329            container_type c = container_type ();
330            size_type n (0);
331            // Beginning of range
332            const_iterator_type cit_begin (c.begin ());
333            // End of range
334            const_iterator_type cit_end (c.end ());
335            // Size
336            n = c.size ();
337            ignore_unused_variable_warning (cit_end);
338            ignore_unused_variable_warning (cit_begin);
339            ignore_unused_variable_warning (n);
340        }
341    };
342
343    template<class C>
344    struct MutableContainerConcept {
345        typedef C container_type;
346        typedef typename C::iterator iterator_type;
347
348        static void constraints () {
349            AssignableConcept<container_type>::constraints (container_type ());
350            ContainerConcept<container_type>::constraints ();
351            container_type c = container_type (), c1 = container_type (), c2 = container_type ();
352            // Beginning of range
353            iterator_type it_begin (c.begin ());
354            // End of range
355            iterator_type it_end (c.end ());
356            // Swap
357            c1.swap (c2);
358            ignore_unused_variable_warning (it_end);
359            ignore_unused_variable_warning (it_begin);
360        }
361    };
362
363    template<class C>
364    struct ReversibleContainerConcept {
365        typedef C container_type;
366        typedef typename C::const_reverse_iterator const_reverse_iterator_type;
367
368        static void constraints () {
369            ContainerConcept<container_type>::constraints ();
370            const container_type cc = container_type ();
371            // Beginning of reverse range
372            const_reverse_iterator_type crit_begin (cc.rbegin ());
373            // End of reverse range
374            const_reverse_iterator_type crit_end (cc.rend ());
375            ignore_unused_variable_warning (crit_end);
376            ignore_unused_variable_warning (crit_begin);
377        }
378    };
379
380    template<class C>
381    struct MutableReversibleContainerConcept {
382        typedef C container_type;
383        typedef typename C::reverse_iterator reverse_iterator_type;
384
385        static void constraints () {
386            MutableContainerConcept<container_type>::constraints ();
387            ReversibleContainerConcept<container_type>::constraints ();
388            container_type c = container_type ();
389            // Beginning of reverse range
390            reverse_iterator_type rit_begin (c.rbegin ());
391            // End of reverse range
392            reverse_iterator_type rit_end (c.rend ());
393            ignore_unused_variable_warning (rit_end);
394            ignore_unused_variable_warning (rit_begin);
395        }
396    };
397
398    template<class C>
399    struct RandomAccessContainerConcept {
400        typedef C container_type;
401        typedef typename C::size_type size_type;
402        typedef typename C::value_type value_type;
403
404        static void constraints () {
405            ReversibleContainerConcept<container_type>::constraints ();
406            container_type c = container_type ();
407            size_type n (0);
408            value_type t = value_type ();
409            // Element access
410            t = c [n];
411            ignore_unused_variable_warning (t);
412        }
413    };
414
415    template<class C>
416    struct MutableRandomAccessContainerConcept {
417        typedef C container_type;
418        typedef typename C::size_type size_type;
419        typedef typename C::value_type value_type;
420
421        static void constraints () {
422            MutableReversibleContainerConcept<container_type>::constraints ();
423            RandomAccessContainerConcept<container_type>::constraints ();
424            container_type c = container_type ();
425            size_type n (0);
426            value_type t = value_type ();
427            // Element access
428            c [n] = t;
429        }
430    };
431
432    template<class C>
433    struct StorageArrayConcept {
434        typedef C container_type;
435        typedef typename C::size_type size_type;
436        typedef typename C::value_type value_type;
437
438        static void constraints () {
439            RandomAccessContainerConcept<container_type>::constraints ();
440            size_type n (0);
441            // Sizing constructor
442            container_type c = container_type (n);
443            // Initialised sizing constructor
444            container_type (n, value_type (5));
445            ignore_unused_variable_warning (c);
446        }
447    };
448
449    template<class C>
450    struct MutableStorageArrayConcept {
451        typedef C container_type;
452        typedef typename C::size_type size_type;
453        typedef typename C::value_type value_type;
454        typedef typename C::iterator iterator_type;
455
456        static void constraints () {
457            MutableRandomAccessContainerConcept<container_type>::constraints ();
458            size_type n (0);
459            // Sizing constructor
460            container_type c = container_type (n);
461            // Initialised sizing constructor
462            c = container_type (n, value_type (3));
463            // Resize
464            c.resize (n, value_type (5));
465            // Resize - none preserving
466            c.resize (n);
467        }
468    };
469
470    template<class C>
471    struct StorageSparseConcept {
472        typedef C container_type;
473        typedef typename C::size_type size_type;
474
475        static void constraints () {
476            ReversibleContainerConcept<container_type>::constraints ();
477        }
478    };
479
480    template<class C>
481    struct MutableStorageSparseConcept {
482        typedef C container_type;
483        typedef typename C::size_type size_type;
484        typedef typename C::value_type value_type;
485        typedef typename C::iterator iterator_type;
486
487        static void constraints () {
488            MutableReversibleContainerConcept<container_type>::constraints ();
489            container_type c = container_type ();
490            value_type t = value_type ();
491            iterator_type it = iterator_type (), it1 = iterator_type (), it2 = iterator_type ();
492            // Insert
493            c.insert (it, t);
494            // Erase
495            c.erase (it);
496            // Range erase
497            c.erase (it1, it2);
498            // Clear
499            c.clear ();
500        }
501    };
502
503    template<class G>
504    struct IndexSetConcept {
505        typedef G generator_type;
506        typedef typename G::size_type size_type;
507        typedef typename G::value_type value_type;
508
509        static void constraints () {
510            AssignableConcept<generator_type>::constraints (generator_type ());
511            ReversibleContainerConcept<generator_type>::constraints ();
512            generator_type g = generator_type ();
513            size_type n (0);
514            value_type t;
515            // Element access
516            t = g (n);
517            ignore_unused_variable_warning (t);
518        }
519    };
520
521    template<class SE>
522    struct ScalarExpressionConcept {
523        typedef SE scalar_expression_type;
524        typedef typename SE::value_type value_type;
525
526        static void constraints () {
527                scalar_expression_type *sp;
528            scalar_expression_type s = *sp;
529            value_type t;
530            // Conversion
531            t = s;
532            ignore_unused_variable_warning (t);
533        }
534    };
535
536    template<class VE>
537    struct VectorExpressionConcept {
538        typedef VE vector_expression_type;
539        typedef typename VE::type_category type_category;
540        typedef typename VE::size_type size_type;
541        typedef typename VE::value_type value_type;
542        typedef typename VE::const_iterator const_iterator_type;
543        typedef typename VE::const_reverse_iterator const_reverse_iterator_type;
544
545        static void constraints () {
546                vector_expression_type *vp;
547                const vector_expression_type *cvp;
548            vector_expression_type v = *vp;
549            const vector_expression_type cv = *cvp;
550            size_type n (0), i (0);
551            value_type t;
552            // Find (internal?)
553            const_iterator_type cit (v.find (i));
554            // Beginning of range
555            const_iterator_type cit_begin (v.begin ());
556            // End of range
557            const_iterator_type cit_end (v.end ());
558            // Size
559            n = v.size ();
560            // Beginning of reverse range
561            const_reverse_iterator_type crit_begin (cv.rbegin ());
562            // End of reverse range
563            const_reverse_iterator_type crit_end (cv.rend ());
564            // Element access
565            t = v (i);
566            ignore_unused_variable_warning (n);
567            ignore_unused_variable_warning (cit);
568            ignore_unused_variable_warning (cit_begin);
569            ignore_unused_variable_warning (cit_end);
570            ignore_unused_variable_warning (crit_begin);
571            ignore_unused_variable_warning (crit_end);
572            ignore_unused_variable_warning (t);
573        }
574    };
575
576    template<class VE>
577    struct MutableVectorExpressionConcept {
578        typedef VE vector_expression_type;
579        typedef typename VE::size_type size_type;
580        typedef typename VE::value_type value_type;
581        typedef typename VE::iterator iterator_type;
582        typedef typename VE::reverse_iterator reverse_iterator_type;
583
584        static void constraints () {
585                vector_expression_type *vp;
586            AssignableConcept<vector_expression_type>::constraints (*vp);
587            VectorExpressionConcept<vector_expression_type>::constraints ();
588            vector_expression_type v = *vp, v1 = *vp, v2 = *vp;
589            size_type i (0);
590            value_type t = value_type ();
591            // Find (internal?)
592            iterator_type it (v.find (i));
593            // Beginning of range
594            iterator_type it_begin (v.begin ());
595            // End of range
596            iterator_type it_end (v.end ());
597            // Swap
598            v1.swap (v2);
599            // Beginning of reverse range
600            reverse_iterator_type rit_begin (v.rbegin ());
601            // End of reverse range
602            reverse_iterator_type rit_end (v.rend ());
603            // Assignments
604            v2 = v1;
605            v2.assign (v1);
606            v2 += v1;
607            v2.plus_assign (v1);
608            v2 -= v1;
609            v2.minus_assign (v1);
610            v *= t;
611            ignore_unused_variable_warning (it);
612            ignore_unused_variable_warning (it_begin);
613            ignore_unused_variable_warning (it_end);
614            ignore_unused_variable_warning (rit_begin);
615            ignore_unused_variable_warning (rit_end);
616        }
617    };
618
619    template<class ME>
620    struct MatrixExpressionConcept {
621        typedef ME matrix_expression_type;
622        typedef typename ME::type_category type_category;
623        typedef typename ME::size_type size_type;
624        typedef typename ME::value_type value_type;
625        typedef typename ME::const_iterator1 const_subiterator1_type;
626        typedef typename ME::const_iterator2 const_subiterator2_type;
627        typedef typename ME::const_reverse_iterator1 const_reverse_subiterator1_type;
628        typedef typename ME::const_reverse_iterator2 const_reverse_subiterator2_type;
629
630        static void constraints () {
631                matrix_expression_type *mp;
632                const matrix_expression_type *cmp;
633            matrix_expression_type m = *mp;
634            const matrix_expression_type cm = *cmp;
635            size_type n (0), i (0), j (0);
636            value_type t;
637            // Find (internal?)
638            const_subiterator1_type cit1 (m.find1 (0, i, j));
639            const_subiterator2_type cit2 (m.find2 (0, i, j));
640            // Beginning of range
641            const_subiterator1_type cit1_begin (m.begin1 ());
642            const_subiterator2_type cit2_begin (m.begin2 ());
643            // End of range
644            const_subiterator1_type cit1_end (m.end1 ());
645            const_subiterator2_type cit2_end (m.end2 ());
646            // Size
647            n = m.size1 ();
648            n = m.size2 ();
649            // Beginning of reverse range
650            const_reverse_subiterator1_type crit1_begin (cm.rbegin1 ());
651            const_reverse_subiterator2_type crit2_begin (cm.rbegin2 ());
652            // End of reverse range
653            const_reverse_subiterator1_type crit1_end (cm.rend1 ());
654            const_reverse_subiterator2_type crit2_end (cm.rend2 ());
655            // Element access
656            t = m (i, j);
657            ignore_unused_variable_warning (n);
658            ignore_unused_variable_warning (cit1);
659            ignore_unused_variable_warning (cit2);
660            ignore_unused_variable_warning (cit1_begin);
661            ignore_unused_variable_warning (cit2_begin);
662            ignore_unused_variable_warning (cit1_end);
663            ignore_unused_variable_warning (cit2_end);
664            ignore_unused_variable_warning (crit1_begin);
665            ignore_unused_variable_warning (crit2_begin);
666            ignore_unused_variable_warning (crit1_end);
667            ignore_unused_variable_warning (crit2_end);
668            ignore_unused_variable_warning (t);
669        }
670    };
671
672    template<class ME>
673    struct MutableMatrixExpressionConcept {
674        typedef ME matrix_expression_type;
675        typedef typename ME::size_type size_type;
676        typedef typename ME::value_type value_type;
677        typedef typename ME::iterator1 subiterator1_type;
678        typedef typename ME::iterator2 subiterator2_type;
679        typedef typename ME::reverse_iterator1 reverse_subiterator1_type;
680        typedef typename ME::reverse_iterator2 reverse_subiterator2_type;
681
682        static void constraints () {
683                matrix_expression_type *mp;
684            AssignableConcept<matrix_expression_type>::constraints (*mp);
685            MatrixExpressionConcept<matrix_expression_type>::constraints ();
686            matrix_expression_type m = *mp, m1 = *mp, m2 = *mp;
687            size_type i (0), j (0);
688            value_type t = value_type ();
689            // Find (internal?)
690            subiterator1_type it1 (m.find1 (0, i, j));
691            subiterator2_type it2 (m.find2 (0, i, j));
692            // Beginning of range
693            subiterator1_type it1_begin (m.begin1 ());
694            subiterator2_type it2_begin (m.begin2 ());
695            // End of range
696            subiterator1_type it1_end (m.end1 ());
697            subiterator2_type it2_end (m.end2 ());
698            // Swap
699            m1.swap (m2);
700            // Beginning of reverse range
701            reverse_subiterator1_type rit1_begin (m.rbegin1 ());
702            reverse_subiterator2_type rit2_begin (m.rbegin2 ());
703            // End of reverse range
704            reverse_subiterator1_type rit1_end (m.rend1 ());
705            reverse_subiterator2_type rit2_end (m.rend2 ());
706            // Assignments
707            m2 = m1;
708            m2.assign (m1);
709            m2 += m1;
710            m2.plus_assign (m1);
711            m2 -= m1;
712            m2.minus_assign (m1);
713            m *= t;
714            ignore_unused_variable_warning (it1);
715            ignore_unused_variable_warning (it2);
716            ignore_unused_variable_warning (it1_begin);
717            ignore_unused_variable_warning (it2_begin);
718            ignore_unused_variable_warning (it1_end);
719            ignore_unused_variable_warning (it2_end);
720            ignore_unused_variable_warning (rit1_begin);
721            ignore_unused_variable_warning (rit2_begin);
722            ignore_unused_variable_warning (rit1_end);
723            ignore_unused_variable_warning (rit2_end);
724        }
725    };
726
727    template<class V>
728    struct VectorConcept {
729        typedef V vector_type;
730        typedef typename V::size_type size_type;
731        typedef typename V::value_type value_type;
732        typedef const value_type *const_pointer;
733
734        static void constraints () {
735            VectorExpressionConcept<vector_type>::constraints ();
736            size_type n (0);
737            size_type i (0);
738            // Sizing constructor
739            vector_type v (n);
740            // Element support
741            const_pointer p = v.find_element (i);
742
743            ignore_unused_variable_warning (p);
744        }
745    };
746
747    template<class V>
748    struct MutableVectorConcept {
749        typedef V vector_type;
750        typedef typename V::size_type size_type;
751        typedef typename V::value_type value_type;
752        typedef value_type *pointer;
753
754        static void constraints () {
755            VectorConcept<vector_type>::constraints ();
756            MutableVectorExpressionConcept<vector_type>::constraints ();
757            size_type n (0);
758            value_type t = value_type ();
759            size_type i (0);
760            // Sizing constructor
761            vector_type v (n);
762            // Element support
763            pointer p = v.find_element (i);
764            // Element assignment
765            value_type r = v.insert_element (i, t);
766            v.insert_element (i, t) = r;
767            // Zeroing
768            v.clear ();
769            // Resize
770            v.resize (n);
771
772            ignore_unused_variable_warning (p);
773            ignore_unused_variable_warning (r);
774        }
775    };
776
777    template<class V>
778    struct SparseVectorConcept {
779        typedef V vector_type;
780        typedef typename V::size_type size_type;
781
782        static void constraints () {
783            VectorConcept<vector_type>::constraints ();
784        }
785    };
786
787    template<class V>
788    struct MutableSparseVectorConcept {
789        typedef V vector_type;
790        typedef typename V::size_type size_type;
791        typedef typename V::value_type value_type;
792
793        static void constraints () {
794            SparseVectorConcept<vector_type>::constraints ();
795            MutableVectorConcept<vector_type>::constraints ();
796            size_type n (0);
797            size_type i (0);
798            // Sizing constructor
799            vector_type v (n);
800            // Element erasure
801            v.erase_element (i);
802        }
803    };
804
805    template<class M>
806    struct MatrixConcept {
807        typedef M matrix_type;
808        typedef typename M::size_type size_type;
809        typedef typename M::value_type value_type;
810        typedef const value_type *const_pointer;
811
812        static void constraints () {
813            MatrixExpressionConcept<matrix_type>::constraints ();
814            size_type n (0);
815            size_type i (0), j (0);
816            // Sizing constructor
817            matrix_type m (n, n);
818            // Element support
819#ifndef SKIP_BAD
820            const_pointer p = m.find_element (i, j);
821#else
822            const_pointer p;
823            ignore_unused_variable_warning (i);
824            ignore_unused_variable_warning (j);
825#endif
826            ignore_unused_variable_warning (p);
827        }
828    };
829
830    template<class M>
831    struct MutableMatrixConcept {
832        typedef M matrix_type;
833        typedef typename M::size_type size_type;
834        typedef typename M::value_type value_type;
835        typedef value_type *pointer;
836
837        static void constraints () {
838            MatrixConcept<matrix_type>::constraints ();
839            MutableMatrixExpressionConcept<matrix_type>::constraints ();
840            size_type n (0);
841            value_type t = value_type ();
842            size_type i (0), j (0);
843            // Sizing constructor
844            matrix_type m (n, n);
845            // Element support
846#ifndef SKIP_BAD
847            pointer p = m.find_element (i, j);
848            ignore_unused_variable_warning (i);
849            ignore_unused_variable_warning (j);
850#else
851            pointer p;
852#endif
853            // Element assigment
854            value_type r = m.insert_element (i, j, t);
855            m.insert_element (i, j, t) = r;
856            // Zeroing
857            m.clear ();
858            // Resize
859            m.resize (n, n);
860            m.resize (n, n, false);
861
862            ignore_unused_variable_warning (p);
863            ignore_unused_variable_warning (r);
864        }
865    };
866
867    template<class M>
868    struct SparseMatrixConcept {
869        typedef M matrix_type;
870        typedef typename M::size_type size_type;
871
872        static void constraints () {
873            MatrixConcept<matrix_type>::constraints ();
874        }
875    };
876
877    template<class M>
878    struct MutableSparseMatrixConcept {
879        typedef M matrix_type;
880        typedef typename M::size_type size_type;
881        typedef typename M::value_type value_type;
882
883        static void constraints () {
884            SparseMatrixConcept<matrix_type>::constraints ();
885            MutableMatrixConcept<matrix_type>::constraints ();
886            size_type n (0);
887            size_type i (0), j (0);
888            // Sizing constructor
889            matrix_type m (n, n);
890            // Elemnent erasure
891            m.erase_element (i, j);
892        }
893    };
894
895    template<class T>
896    T
897    ZeroElement (T);
898    template<>
899    float
900    ZeroElement (float) {
901        return 0.f;
902    }
903    template<>
904    double
905    ZeroElement (double) {
906        return 0.;
907    }
908    template<>
909    vector<float>
910    ZeroElement (vector<float>) {
911        return zero_vector<float> ();
912    }
913    template<>
914    vector<double>
915    ZeroElement (vector<double>) {
916        return zero_vector<double> ();
917    }
918    template<>
919    matrix<float>
920    ZeroElement (matrix<float>) {
921        return zero_matrix<float> ();
922    }
923    template<>
924    matrix<double>
925    ZeroElement (matrix<double>) {
926        return zero_matrix<double> ();
927    }
928    template<>
929    std::complex<float>
930    ZeroElement (std::complex<float>) {
931        return std::complex<float> (0.f);
932    }
933    template<>
934    std::complex<double>
935    ZeroElement (std::complex<double>) {
936        return std::complex<double> (0.);
937    }
938    template<>
939    vector<std::complex<float> >
940    ZeroElement (vector<std::complex<float> >) {
941        return zero_vector<std::complex<float> > ();
942    }
943    template<>
944    vector<std::complex<double> >
945    ZeroElement (vector<std::complex<double> >) {
946        return zero_vector<std::complex<double> > ();
947    }
948    template<>
949    matrix<std::complex<float> >
950    ZeroElement (matrix<std::complex<float> >) {
951        return zero_matrix<std::complex<float> > ();
952    }
953    template<>
954    matrix<std::complex<double> >
955    ZeroElement (matrix<std::complex<double> >) {
956        return zero_matrix<std::complex<double> > ();
957    }
958
959    template<class T>
960    T
961    OneElement (T);
962    template<>
963    float
964    OneElement (float) {
965        return 1.f;
966    }
967    template<>
968    double
969    OneElement (double) {
970        return 1.;
971    }
972    template<>
973    matrix<float>
974    OneElement (matrix<float>) {
975        return identity_matrix<float> ();
976    }
977    template<>
978    matrix<double>
979    OneElement (matrix<double>) {
980        return identity_matrix<double> ();
981    }
982    template<>
983    std::complex<float>
984    OneElement (std::complex<float>) {
985        return std::complex<float> (1.f);
986    }
987    template<>
988    std::complex<double>
989    OneElement (std::complex<double>) {
990        return std::complex<double> (1.);
991    }
992    template<>
993    matrix<std::complex<float> >
994    OneElement (matrix<std::complex<float> >) {
995        return identity_matrix<std::complex<float> > ();
996    }
997    template<>
998    matrix<std::complex<double> >
999    OneElement (matrix<std::complex<double> >) {
1000        return identity_matrix<std::complex<double> > ();
1001    }
1002
1003    template<class E1, class E2>
1004    bool
1005    operator == (const vector_expression<E1> &e1, const vector_expression<E2> &e2) {
1006        typedef typename promote_traits<typename E1::value_type,
1007                                                    typename E2::value_type>::promote_type value_type;
1008        typedef typename type_traits<value_type>::real_type real_type;
1009        return norm_inf (e1 - e2) == real_type/*zero*/();
1010    }
1011    template<class E1, class E2>
1012    bool
1013    operator == (const matrix_expression<E1> &e1, const matrix_expression<E2> &e2) {
1014        typedef typename promote_traits<typename E1::value_type,
1015                                                    typename E2::value_type>::promote_type value_type;
1016        typedef typename type_traits<value_type>::real_type real_type;
1017        return norm_inf (e1 - e2) == real_type/*zero*/();
1018    }
1019
1020    template<class T>
1021    struct AdditiveAbelianGroupConcept {
1022        typedef T value_type;
1023
1024        static void constraints () {
1025            bool r;
1026            value_type a = value_type (), b = value_type (), c = value_type ();
1027            r = (a + b) + c == a + (b + c);
1028            r = ZeroElement (value_type ()) + a == a;
1029            r = a + ZeroElement (value_type ()) == a;
1030            r = a + (- a) == ZeroElement (value_type ());
1031            r = (- a) + a == ZeroElement (value_type ());
1032            r = a + b == b + a;
1033            ignore_unused_variable_warning (r);
1034        }
1035    };
1036
1037    template<class T>
1038    struct MultiplicativeAbelianGroupConcept {
1039        typedef T value_type;
1040
1041        static void constraints () {
1042            bool r;
1043            value_type a = value_type (), b = value_type (), c = value_type ();
1044            r = (a * b) * c == a * (b * c);
1045            r = OneElement (value_type ()) * a == a;
1046            r = a * OneElement (value_type ()) == a;
1047            r = a * (OneElement (value_type ()) / a) == a;
1048            r = (OneElement (value_type ()) / a) * a == a;
1049            r = a * b == b * a;
1050            ignore_unused_variable_warning (r);
1051        }
1052    };
1053
1054    template<class T>
1055    struct RingWithIdentityConcept {
1056        typedef T value_type;
1057
1058        static void constraints () {
1059            AdditiveAbelianGroupConcept<value_type>::constraints ();
1060            bool r;
1061            value_type a = value_type (), b = value_type (), c = value_type ();
1062            r = (a * b) * c == a * (b * c);
1063            r = (a + b) * c == a * c + b * c;
1064            r = OneElement (value_type ()) * a == a;
1065            r = a * OneElement (value_type ()) == a;
1066            ignore_unused_variable_warning (r);
1067        }
1068        static void constraints (int) {
1069            AdditiveAbelianGroupConcept<value_type>::constraints ();
1070            bool r;
1071            value_type a = value_type (), b = value_type (), c = value_type ();
1072            r = prod (T (prod (a, b)), c) == prod (a, T (prod (b, c)));
1073            r = prod (a + b, c) == prod (a, c) + prod (b, c);
1074            r = prod (OneElement (value_type ()), a) == a;
1075            r = prod (a, OneElement (value_type ())) == a;
1076            ignore_unused_variable_warning (r);
1077        }
1078    };
1079
1080    template<class T>
1081    struct CommutativeRingWithIdentityConcept {
1082        typedef T value_type;
1083
1084        static void constraints () {
1085            RingWithIdentityConcept<value_type>::constraints ();
1086            bool r;
1087            value_type a = value_type (), b = value_type ();
1088            r = a * b == b * a;
1089            ignore_unused_variable_warning (r);
1090        }
1091    };
1092
1093    template<class T>
1094    struct FieldConcept {
1095        typedef T value_type;
1096
1097        static void constraints () {
1098            CommutativeRingWithIdentityConcept<value_type>::constraints ();
1099            bool r;
1100            value_type a = value_type ();
1101            r = a == ZeroElement (value_type ()) || a * (OneElement (value_type ()) / a) == a;
1102            r = a == ZeroElement (value_type ()) || (OneElement (value_type ()) / a) * a == a;
1103            ignore_unused_variable_warning (r);
1104        }
1105    };
1106
1107    template<class T, class V>
1108    struct VectorSpaceConcept {
1109        typedef T value_type;
1110        typedef V vector_type;
1111
1112        static void constraints () {
1113            FieldConcept<value_type>::constraints ();
1114            AdditiveAbelianGroupConcept<vector_type>::constraints ();
1115            bool r;
1116            value_type alpha = value_type (), beta = value_type ();
1117            vector_type a = vector_type (), b = vector_type ();
1118            r = alpha * (a + b) == alpha * a + alpha * b;
1119            r = (alpha + beta) * a == alpha * a + beta * a;
1120            r = (alpha * beta) * a == alpha * (beta * a);
1121            r = OneElement (value_type ()) * a == a;
1122            ignore_unused_variable_warning (r);
1123        }
1124    };
1125
1126    template<class T, class V, class M>
1127    struct LinearOperatorConcept {
1128        typedef T value_type;
1129        typedef V vector_type;
1130        typedef M matrix_type;
1131
1132        static void constraints () {
1133            VectorSpaceConcept<value_type, vector_type>::constraints ();
1134            bool r;
1135            value_type alpha = value_type (), beta = value_type ();
1136            vector_type a = vector_type (), b = vector_type ();
1137            matrix_type A = matrix_type ();
1138            r = prod (A, alpha * a + beta * b) == alpha * prod (A, a) + beta * prod (A, b);
1139            ignore_unused_variable_warning (r);
1140        }
1141    };
1142
1143    void concept_checks () {
1144
1145        // Allow tests to be group to keep down compiler storage requirement
1146#ifdef INTERAL
1147#define INTERNAL_STORAGE
1148#define INTERNAL_VECTOR
1149#define INTERNAL_MATRIX
1150#define INTERNAL_SPECIAL
1151#define INTERNAL_SPARSE
1152#define INTERNAL_EXPRESSION
1153#endif
1154
1155        // Element value type for tests
1156        typedef float T;
1157
1158        // Storage Array
1159#if defined (INTERNAL_STORAGE) || defined (INTERNAL_STORAGE_DENSE)
1160        StorageArrayConcept<const std::vector<T> >::constraints ();
1161        MutableStorageArrayConcept<std::vector<T> >::constraints ();
1162        RandomAccessIteratorConcept<std::vector<T>::const_iterator>::constraints ();
1163        MutableRandomAccessIteratorConcept<std::vector<T>::iterator>::constraints ();
1164
1165        StorageArrayConcept<const bounded_array<T, 1> >::constraints ();
1166        MutableStorageArrayConcept<bounded_array<T, 1> >::constraints ();
1167        RandomAccessIteratorConcept<bounded_array<T, 1>::const_iterator>::constraints ();
1168        MutableRandomAccessIteratorConcept<bounded_array<T, 1>::iterator>::constraints ();
1169
1170        StorageArrayConcept<const unbounded_array<T> >::constraints ();
1171        MutableStorageArrayConcept<unbounded_array<T> >::constraints ();
1172        RandomAccessIteratorConcept<unbounded_array<T>::const_iterator>::constraints ();
1173        MutableRandomAccessIteratorConcept<unbounded_array<T>::iterator>::constraints ();
1174
1175        StorageArrayConcept<const array_adaptor<T> >::constraints ();
1176        MutableStorageArrayConcept<array_adaptor<T> >::constraints ();
1177        RandomAccessIteratorConcept<array_adaptor<T>::const_iterator>::constraints ();
1178        MutableRandomAccessIteratorConcept<array_adaptor<T>::iterator>::constraints ();
1179
1180        IndexSetConcept<range>::constraints ();
1181        RandomAccessIteratorConcept<range::const_iterator>::constraints ();
1182
1183        IndexSetConcept<slice>::constraints ();
1184        RandomAccessIteratorConcept<slice::const_iterator>::constraints ();
1185
1186        IndexSetConcept<indirect_array<> >::constraints ();
1187        RandomAccessIteratorConcept<indirect_array<>::const_iterator>::constraints ();
1188#endif
1189
1190        // Storage Sparse
1191#if defined (INTERNAL_STORAGE) || defined (INTERNAL_STORAGE_SPARSE)
1192        StorageSparseConcept<const map_array<std::size_t, T> >::constraints ();
1193        MutableStorageSparseConcept<map_array<std::size_t, T> >::constraints ();
1194        RandomAccessIteratorConcept<map_array<std::size_t, T>::const_iterator>::constraints ();
1195        MutableRandomAccessIteratorConcept<map_array<std::size_t, T>::iterator>::constraints ();
1196
1197        StorageSparseConcept<const std::map<std::size_t, T> >::constraints ();
1198        MutableStorageSparseConcept<std::map<std::size_t, T> >::constraints ();
1199        BidirectionalIteratorConcept<std::map<std::size_t, T>::const_iterator>::constraints ();
1200                // Not value_type mutable
1201        BidirectionalIteratorConcept<std::map<std::size_t, T>::iterator>::constraints ();
1202#endif
1203
1204        // Vector
1205#if defined (INTERNAL_VECTOR) || defined (INTERNAL_VECTOR_DENSE)
1206        VectorConcept<const vector<T> >::constraints ();
1207        MutableVectorConcept<vector<T> >::constraints ();
1208        IndexedRandomAccess1DIteratorConcept<vector<T>::const_iterator>::constraints ();
1209        MutableIndexedRandomAccess1DIteratorConcept<vector<T>::iterator>::constraints ();
1210        IndexedRandomAccess1DIteratorConcept<vector<T>::const_reverse_iterator>::constraints ();
1211        MutableIndexedRandomAccess1DIteratorConcept<vector<T>::reverse_iterator>::constraints ();
1212
1213        VectorConcept<zero_vector<T> >::constraints ();
1214        IndexedBidirectional1DIteratorConcept<zero_vector<T>::const_iterator>::constraints ();
1215        IndexedBidirectional1DIteratorConcept<zero_vector<T>::const_reverse_iterator>::constraints ();
1216
1217        VectorConcept<unit_vector<T> >::constraints ();
1218        IndexedBidirectional1DIteratorConcept<unit_vector<T>::const_iterator>::constraints ();
1219        IndexedBidirectional1DIteratorConcept<unit_vector<T>::const_reverse_iterator>::constraints ();
1220
1221        VectorConcept<scalar_vector<T> >::constraints ();
1222        IndexedRandomAccess1DIteratorConcept<scalar_vector<T>::const_iterator>::constraints ();
1223        IndexedRandomAccess1DIteratorConcept<scalar_vector<T>::const_reverse_iterator>::constraints ();
1224
1225        VectorConcept<const c_vector<T, 1> >::constraints ();
1226        MutableVectorConcept<c_vector<T, 1> >::constraints ();
1227        IndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::const_iterator>::constraints ();
1228        MutableIndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::iterator>::constraints ();
1229        IndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::const_reverse_iterator>::constraints ();
1230        MutableIndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::reverse_iterator>::constraints ();
1231#endif
1232
1233        // Vector Proxies
1234#if defined (INTERNAL_VECTOR) || defined (INTERNAL_VECTOR_PROXY)
1235        VectorExpressionConcept<const vector_range<const vector<T> > >::constraints ();
1236        MutableVectorExpressionConcept<vector_range<vector<T> > >::constraints ();
1237        IndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::const_iterator>::constraints ();
1238        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::iterator>::constraints ();
1239        IndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::const_reverse_iterator>::constraints ();
1240        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::reverse_iterator>::constraints ();
1241
1242        VectorExpressionConcept<const vector_slice<const vector<T> > >::constraints ();
1243        MutableVectorExpressionConcept<vector_slice<vector<T> > >::constraints ();
1244        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::const_iterator>::constraints ();
1245        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::iterator>::constraints ();
1246        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::const_reverse_iterator>::constraints ();
1247        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::reverse_iterator>::constraints ();
1248
1249        VectorExpressionConcept<const vector_indirect<const vector<T> > >::constraints ();
1250        MutableVectorExpressionConcept<vector_indirect<vector<T> > >::constraints ();
1251        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::const_iterator>::constraints ();
1252        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::iterator>::constraints ();
1253        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::const_reverse_iterator>::constraints ();
1254        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::reverse_iterator>::constraints ();
1255#endif
1256
1257        // Sparse Vector
1258#if defined (INTERNAL_SPARSE) || defined (INTERNAL_VECTOR_SPARSE)
1259        SparseVectorConcept<const mapped_vector<T> >::constraints ();
1260        MutableSparseVectorConcept<mapped_vector<T> >::constraints ();
1261        IndexedBidirectional1DIteratorConcept<mapped_vector<T>::const_iterator>::constraints ();
1262        MutableIndexedBidirectional1DIteratorConcept<mapped_vector<T>::iterator>::constraints ();
1263        IndexedBidirectional1DIteratorConcept<mapped_vector<T>::const_reverse_iterator>::constraints ();
1264        MutableIndexedBidirectional1DIteratorConcept<mapped_vector<T>::reverse_iterator>::constraints ();
1265
1266        SparseVectorConcept<const compressed_vector<T> >::constraints ();
1267        MutableSparseVectorConcept<compressed_vector<T> >::constraints ();
1268        IndexedBidirectional1DIteratorConcept<compressed_vector<T>::const_iterator>::constraints ();
1269        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<T>::iterator>::constraints ();
1270        IndexedBidirectional1DIteratorConcept<compressed_vector<T>::const_reverse_iterator>::constraints ();
1271        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<T>::reverse_iterator>::constraints ();
1272
1273        SparseVectorConcept<const coordinate_vector<T> >::constraints ();
1274        MutableSparseVectorConcept<coordinate_vector<T> >::constraints ();
1275        IndexedBidirectional1DIteratorConcept<coordinate_vector<T>::const_iterator>::constraints ();
1276        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<T>::iterator>::constraints ();
1277        IndexedBidirectional1DIteratorConcept<coordinate_vector<T>::const_reverse_iterator>::constraints ();
1278        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<T>::reverse_iterator>::constraints ();
1279#endif
1280
1281        // Matrix
1282#if defined (INTERNAL_MATRIX) || defined (INTERNAL_MATRIX_DENSE)
1283        MatrixConcept<const matrix<T> >::constraints ();
1284        MutableMatrixConcept<matrix<T> >::constraints ();
1285        IndexedRandomAccess2DIteratorConcept<matrix<T>::const_iterator1,
1286                                             matrix<T>::const_iterator2>::constraints ();
1287        MutableIndexedRandomAccess2DIteratorConcept<matrix<T>::iterator1,
1288                                                    matrix<T>::iterator2>::constraints ();
1289        IndexedRandomAccess2DIteratorConcept<matrix<T>::const_reverse_iterator1,
1290                                             matrix<T>::const_reverse_iterator2>::constraints ();
1291        MutableIndexedRandomAccess2DIteratorConcept<matrix<T>::reverse_iterator1,
1292                                                    matrix<T>::reverse_iterator2>::constraints ();
1293
1294        MatrixConcept<const vector_of_vector<T> >::constraints ();
1295        MutableMatrixConcept<vector_of_vector<T> >::constraints ();
1296        IndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::const_iterator1,
1297                                             vector_of_vector<T>::const_iterator2>::constraints ();
1298        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::iterator1,
1299                                                    vector_of_vector<T>::iterator2>::constraints ();
1300        IndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::const_reverse_iterator1,
1301                                             vector_of_vector<T>::const_reverse_iterator2>::constraints ();
1302        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::reverse_iterator1,
1303                                                    vector_of_vector<T>::reverse_iterator2>::constraints ();
1304
1305        MatrixConcept<zero_matrix<T> >::constraints ();
1306        IndexedBidirectional2DIteratorConcept<zero_matrix<T>::const_iterator1,
1307                                              zero_matrix<T>::const_iterator2>::constraints ();
1308        IndexedBidirectional2DIteratorConcept<zero_matrix<T>::const_reverse_iterator1,
1309                                              zero_matrix<T>::const_reverse_iterator2>::constraints ();
1310
1311        MatrixConcept<identity_matrix<T> >::constraints ();
1312        IndexedBidirectional2DIteratorConcept<identity_matrix<T>::const_iterator1,
1313                                             identity_matrix<T>::const_iterator2>::constraints ();
1314        IndexedBidirectional2DIteratorConcept<identity_matrix<T>::const_reverse_iterator1,
1315                                             identity_matrix<T>::const_reverse_iterator2>::constraints ();
1316
1317        MatrixConcept<scalar_matrix<T> >::constraints ();
1318        IndexedRandomAccess2DIteratorConcept<scalar_matrix<T>::const_iterator1,
1319                                             scalar_matrix<T>::const_iterator2>::constraints ();
1320        IndexedRandomAccess2DIteratorConcept<scalar_matrix<T>::const_reverse_iterator1,
1321                                             scalar_matrix<T>::const_reverse_iterator2>::constraints ();
1322
1323        MatrixConcept<const c_matrix<T, 1, 1> >::constraints ();
1324        MutableMatrixConcept<c_matrix<T, 1, 1> >::constraints ();
1325        IndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::const_iterator1,
1326                                             c_matrix<T, 1, 1>::const_iterator2>::constraints ();
1327        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::iterator1,
1328                                                    c_matrix<T, 1, 1>::iterator2>::constraints ();
1329        IndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::const_reverse_iterator1,
1330                                             c_matrix<T, 1, 1>::const_reverse_iterator2>::constraints ();
1331        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::reverse_iterator1,
1332                                                    c_matrix<T, 1, 1>::reverse_iterator2>::constraints ();
1333#endif
1334
1335        // Matrix Proxies
1336#if defined (INTERNAL_MATRIX) || defined (INTERNAL_MATRIX_PROXY)
1337        VectorExpressionConcept<const matrix_row<const matrix<T> > >::constraints ();
1338        MutableVectorExpressionConcept<matrix_row<matrix<T> > >::constraints ();
1339        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::const_iterator>::constraints ();
1340        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::iterator>::constraints ();
1341        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::const_reverse_iterator>::constraints ();
1342        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::reverse_iterator>::constraints ();
1343
1344        VectorExpressionConcept<const matrix_column<const matrix<T> > >::constraints ();
1345        MutableVectorExpressionConcept<matrix_column<matrix<T> > >::constraints ();
1346        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::const_iterator>::constraints ();
1347        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::iterator>::constraints ();
1348        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::const_reverse_iterator>::constraints ();
1349        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::reverse_iterator>::constraints ();
1350
1351        VectorExpressionConcept<const matrix_vector_range<const matrix<T> > >::constraints ();
1352        MutableVectorExpressionConcept<matrix_vector_range<matrix<T> > >::constraints ();
1353        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::const_iterator>::constraints ();
1354        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::iterator>::constraints ();
1355        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::const_reverse_iterator>::constraints ();
1356        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::reverse_iterator>::constraints ();
1357
1358        VectorExpressionConcept<const matrix_vector_slice<const matrix<T> > >::constraints ();
1359        MutableVectorExpressionConcept<matrix_vector_slice<matrix<T> > >::constraints ();
1360        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::const_iterator>::constraints ();
1361        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::iterator>::constraints ();
1362        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::const_reverse_iterator>::constraints ();
1363        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::reverse_iterator>::constraints ();
1364
1365        VectorExpressionConcept<const matrix_vector_indirect<const matrix<T>, vector<unsigned> > >::constraints ();
1366        MutableVectorExpressionConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> > >::constraints ();
1367        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::const_iterator>::constraints ();
1368        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::iterator>::constraints ();
1369        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::const_reverse_iterator>::constraints ();
1370        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::reverse_iterator>::constraints ();
1371
1372        MatrixExpressionConcept<const matrix_range<const matrix<T> > >::constraints ();
1373        MutableMatrixExpressionConcept<matrix_range<matrix<T> > >::constraints ();
1374        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::const_iterator1,
1375                                             matrix_range<matrix<T> >::const_iterator2>::constraints ();
1376        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::iterator1,
1377                                                    matrix_range<matrix<T> >::iterator2>::constraints ();
1378        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::const_reverse_iterator1,
1379                                             matrix_range<matrix<T> >::const_reverse_iterator2>::constraints ();
1380        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::reverse_iterator1,
1381                                                    matrix_range<matrix<T> >::reverse_iterator2>::constraints ();
1382
1383        MatrixExpressionConcept<const matrix_slice<const matrix<T> > >::constraints ();
1384        MutableMatrixExpressionConcept<matrix_slice<matrix<T> > >::constraints ();
1385        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::const_iterator1,
1386                                             matrix_slice<matrix<T> >::const_iterator2>::constraints ();
1387        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::iterator1,
1388                                                    matrix_slice<matrix<T> >::iterator2>::constraints ();
1389        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::const_reverse_iterator1,
1390                                             matrix_slice<matrix<T> >::const_reverse_iterator2>::constraints ();
1391        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::reverse_iterator1,
1392                                                    matrix_slice<matrix<T> >::reverse_iterator2>::constraints ();
1393
1394        MatrixExpressionConcept<const matrix_indirect<const matrix<T> > >::constraints ();
1395        MutableMatrixExpressionConcept<matrix_indirect<matrix<T> > >::constraints ();
1396        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::const_iterator1,
1397                                             matrix_indirect<matrix<T> >::const_iterator2>::constraints ();
1398        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::iterator1,
1399                                                    matrix_indirect<matrix<T> >::iterator2>::constraints ();
1400        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::const_reverse_iterator1,
1401                                             matrix_indirect<matrix<T> >::const_reverse_iterator2>::constraints ();
1402        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::reverse_iterator1,
1403                                                    matrix_indirect<matrix<T> >::reverse_iterator2>::constraints ();
1404#endif
1405
1406        // Banded Matrix
1407#if defined (INTERNAL_SPECIAL) || defined (INTERNAL_BANDED)
1408        MatrixConcept<const banded_matrix<T> >::constraints ();
1409        MutableMatrixConcept<banded_matrix<T> >::constraints ();
1410        IndexedRandomAccess2DIteratorConcept<banded_matrix<T>::const_iterator1,
1411                                             banded_matrix<T>::const_iterator2>::constraints ();
1412        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<T>::iterator1,
1413                                                    banded_matrix<T>::iterator2>::constraints ();
1414        IndexedRandomAccess2DIteratorConcept<banded_matrix<T>::const_reverse_iterator1,
1415                                             banded_matrix<T>::const_reverse_iterator2>::constraints ();
1416        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<T>::reverse_iterator1,
1417                                                    banded_matrix<T>::reverse_iterator2>::constraints ();
1418
1419        MatrixExpressionConcept<const banded_adaptor<const matrix<T> > >::constraints ();
1420        MutableMatrixExpressionConcept<banded_adaptor<matrix<T> > >::constraints ();
1421        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::const_iterator1,
1422                                             banded_adaptor<matrix<T> >::const_iterator2>::constraints ();
1423        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::iterator1,
1424                                                    banded_adaptor<matrix<T> >::iterator2>::constraints ();
1425        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::const_reverse_iterator1,
1426                                             banded_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
1427        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::reverse_iterator1,
1428                                                    banded_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
1429#endif
1430
1431        // Triangular Matrix
1432#if defined (INTERNAL_SPECIAL) || defined (INTERNAL_TRIANGULAR)
1433        MatrixConcept<const triangular_matrix<T> >::constraints ();
1434        MutableMatrixConcept<triangular_matrix<T> >::constraints ();
1435        IndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::const_iterator1,
1436                                             triangular_matrix<T>::const_iterator2>::constraints ();
1437        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::iterator1,
1438                                                    triangular_matrix<T>::iterator2>::constraints ();
1439        IndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::const_reverse_iterator1,
1440                                             triangular_matrix<T>::const_reverse_iterator2>::constraints ();
1441        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::reverse_iterator1,
1442                                                    triangular_matrix<T>::reverse_iterator2>::constraints ();
1443
1444        MatrixExpressionConcept<const triangular_adaptor<const matrix<T> > >::constraints ();
1445        MutableMatrixExpressionConcept<triangular_adaptor<matrix<T> > >::constraints ();
1446        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::const_iterator1,
1447                                             triangular_adaptor<matrix<T> >::const_iterator2>::constraints ();
1448        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::iterator1,
1449                                                    triangular_adaptor<matrix<T> >::iterator2>::constraints ();
1450        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::const_reverse_iterator1,
1451                                             triangular_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
1452        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::reverse_iterator1,
1453                                                    triangular_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
1454#endif
1455
1456        // Symmetric Matrix
1457#if defined (INTERNA_SPECIAL) || defined (INTERNAL_SYMMETRIC)
1458        MatrixConcept<const symmetric_matrix<T> >::constraints ();
1459        MutableMatrixConcept<symmetric_matrix<T> >::constraints ();
1460        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::const_iterator1,
1461                                             symmetric_matrix<T>::const_iterator2>::constraints ();
1462        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::iterator1,
1463                                                    symmetric_matrix<T>::iterator2>::constraints ();
1464        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::const_reverse_iterator1,
1465                                             symmetric_matrix<T>::const_reverse_iterator2>::constraints ();
1466        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::reverse_iterator1,
1467                                                    symmetric_matrix<T>::reverse_iterator2>::constraints ();
1468
1469        MatrixExpressionConcept<const symmetric_adaptor<const matrix<T> > >::constraints ();
1470#ifndef SKIP_BAD
1471        // const_iterator (iterator) constructor is bad
1472        MutableMatrixExpressionConcept<symmetric_adaptor<matrix<T> > >::constraints ();
1473#endif
1474        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::const_iterator1,
1475                                             symmetric_adaptor<matrix<T> >::const_iterator2>::constraints ();
1476        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::iterator1,
1477                                                    symmetric_adaptor<matrix<T> >::iterator2>::constraints ();
1478        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::const_reverse_iterator1,
1479                                             symmetric_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
1480        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::reverse_iterator1,
1481                                                    symmetric_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
1482#endif
1483
1484        // Hermitian Matrix
1485#if defined (INTERNAL_SPECIAL) || defined (INTERNAL_HERMITIAN)
1486        MatrixConcept<const hermitian_matrix<T> >::constraints ();
1487        MutableMatrixConcept<hermitian_matrix<T> >::constraints ();
1488        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::const_iterator1,
1489                                             hermitian_matrix<T>::const_iterator2>::constraints ();
1490        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::iterator1,
1491                                                    hermitian_matrix<T>::iterator2>::constraints ();
1492        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::const_reverse_iterator1,
1493                                             hermitian_matrix<T>::const_reverse_iterator2>::constraints ();
1494        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::reverse_iterator1,
1495                                                    hermitian_matrix<T>::reverse_iterator2>::constraints ();
1496
1497        MatrixExpressionConcept<const hermitian_adaptor<const matrix<T> > >::constraints ();
1498#ifndef SKIP_BAD
1499        // const_iterator (iterator) constructor is bad
1500        MutableMatrixExpressionConcept<hermitian_adaptor<matrix<T> > >::constraints ();
1501#endif
1502        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::const_iterator1,
1503                                             hermitian_adaptor<matrix<T> >::const_iterator2>::constraints ();
1504        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::iterator1,
1505                                                    hermitian_adaptor<matrix<T> >::iterator2>::constraints ();
1506        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::const_reverse_iterator1,
1507                                             hermitian_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
1508        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::reverse_iterator1,
1509                                                    hermitian_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
1510#endif
1511
1512        // Sparse Matrix
1513#if defined (INTERNAL_SPARSE) || defined (INTERNAL_MATRIX_SPARSE)
1514        {
1515            typedef mapped_matrix<T> container_model;
1516            SparseMatrixConcept<const container_model>::constraints ();
1517            MutableSparseMatrixConcept<container_model>::constraints ();
1518            IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
1519            MutableIndexedBidirectional2DIteratorConcept<container_model::iterator1, container_model::iterator2>::constraints ();
1520            IndexedBidirectional2DIteratorConcept<container_model::const_reverse_iterator1, container_model::const_reverse_iterator2>::constraints ();
1521            MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
1522        }
1523        {
1524            typedef mapped_vector_of_mapped_vector<T> container_model;
1525            SparseMatrixConcept<const container_model>::constraints ();
1526            MutableSparseMatrixConcept<container_model>::constraints ();
1527            IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
1528            MutableIndexedBidirectional2DIteratorConcept<container_model::iterator1, container_model::iterator2>::constraints ();
1529            IndexedBidirectional2DIteratorConcept<container_model::const_reverse_iterator1, container_model::const_reverse_iterator2>::constraints ();
1530            MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
1531        }
1532        {
1533            typedef compressed_matrix<T> container_model;
1534            SparseMatrixConcept<const container_model>::constraints ();
1535            MutableSparseMatrixConcept<container_model>::constraints ();
1536            IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
1537            MutableIndexedBidirectional2DIteratorConcept<container_model::iterator1, container_model::iterator2>::constraints ();
1538            IndexedBidirectional2DIteratorConcept<container_model::const_reverse_iterator1, container_model::const_reverse_iterator2>::constraints ();
1539            MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
1540        }
1541        {
1542            typedef coordinate_matrix<T> container_model;
1543            SparseMatrixConcept<const container_model>::constraints ();
1544            MutableSparseMatrixConcept<container_model>::constraints ();
1545            IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
1546            MutableIndexedBidirectional2DIteratorConcept<container_model::iterator1, container_model::iterator2>::constraints ();
1547            IndexedBidirectional2DIteratorConcept<container_model::const_reverse_iterator1, container_model::const_reverse_iterator2>::constraints ();
1548            MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
1549        }
1550        {
1551            typedef generalized_vector_of_vector<T, row_major, vector< coordinate_vector<T> > > container_model;
1552            SparseMatrixConcept<const container_model>::constraints ();
1553            MutableSparseMatrixConcept<container_model>::constraints ();
1554            IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
1555            MutableIndexedBidirectional2DIteratorConcept<container_model::iterator1, container_model::iterator2>::constraints ();
1556            IndexedBidirectional2DIteratorConcept<container_model::const_reverse_iterator1, container_model::const_reverse_iterator2>::constraints ();
1557            MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
1558        }
1559
1560#endif
1561
1562        // Scalar Expressions
1563#if defined (INTERNAL_EXPRESSION) || defined (INTERNAL_VECTOR_EXPRESSION)
1564        ScalarExpressionConcept<scalar_value<T > >::constraints ();
1565        ScalarExpressionConcept<scalar_reference<T > >::constraints ();
1566
1567        // Vector Expressions
1568        VectorExpressionConcept<vector_reference<vector<T> > >::constraints ();
1569        MutableVectorExpressionConcept<vector_reference<vector<T> > >::constraints ();
1570        IndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::const_iterator>::constraints ();
1571        MutableIndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::iterator>::constraints ();
1572        IndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::const_reverse_iterator>::constraints ();
1573        MutableIndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::reverse_iterator>::constraints ();
1574
1575        VectorExpressionConcept<vector_unary<vector<T>, scalar_identity<T> > >::constraints ();
1576        IndexedRandomAccess1DIteratorConcept<vector_unary<vector<T>, scalar_identity<T>  >::const_iterator>::constraints ();
1577        IndexedRandomAccess1DIteratorConcept<vector_unary<vector<T>, scalar_identity<T>  >::const_reverse_iterator>::constraints ();
1578
1579        VectorExpressionConcept<vector_binary<vector<T>, vector<T>, scalar_plus<T, T> > >::constraints ();
1580        IndexedRandomAccess1DIteratorConcept<vector_binary<vector<T>, vector<T>, scalar_plus<T, T> >::const_iterator>::constraints ();
1581        IndexedRandomAccess1DIteratorConcept<vector_binary<vector<T>, vector<T>, scalar_plus<T, T> >::const_reverse_iterator>::constraints ();
1582
1583        VectorExpressionConcept<vector_binary_scalar1<T, vector<T>, scalar_multiplies<T, T>  > >::constraints ();
1584        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<T, vector<T>, scalar_multiplies<T, T> >::const_iterator>::constraints ();
1585        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<T, vector<T>, scalar_multiplies<T, T> >::const_reverse_iterator>::constraints ();
1586
1587        VectorExpressionConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T> > >::constraints ();
1588        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_iterator>::constraints ();
1589        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_reverse_iterator>::constraints ();
1590
1591        VectorExpressionConcept<vector_binary_scalar1<scalar_value<T>, vector<T>, scalar_multiplies<T, T> > >::constraints ();
1592        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<scalar_value<T>, vector<T>, scalar_multiplies<T, T> >::const_iterator>::constraints ();
1593        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<scalar_value<T>, vector<T>, scalar_multiplies<T, T> >::const_reverse_iterator>::constraints ();
1594
1595        VectorExpressionConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T> > >::constraints ();
1596        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_iterator>::constraints ();
1597        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_reverse_iterator>::constraints ();
1598
1599        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_sum<T> > >::constraints ();
1600        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_norm_1<T> > >::constraints ();
1601        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_norm_2<T> > >::constraints ();
1602        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_norm_inf<T> > >::constraints ();
1603
1604        ScalarExpressionConcept<vector_scalar_binary<vector<T>, vector<T>, vector_inner_prod<T, T, T> > >::constraints ();
1605#endif
1606
1607        // Matrix Expressions
1608#if defined (INTERNAL_EXPRESSION) || defined (INTERNAL_MATRIX_EXPRESSION)
1609        MatrixExpressionConcept<matrix_reference<matrix<T> > >::constraints ();
1610        MutableMatrixExpressionConcept<matrix_reference<matrix<T> > >::constraints ();
1611        IndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::const_iterator1,
1612                                             matrix_reference<matrix<T> >::const_iterator2>::constraints ();
1613        MutableIndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::iterator1,
1614                                                    matrix_reference<matrix<T> >::iterator2>::constraints ();
1615        IndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::const_reverse_iterator1,
1616                                             matrix_reference<matrix<T> >::const_reverse_iterator2>::constraints ();
1617        MutableIndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::reverse_iterator1,
1618                                                    matrix_reference<matrix<T> >::reverse_iterator2>::constraints ();
1619
1620        MatrixExpressionConcept<vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> > >::constraints ();
1621        IndexedRandomAccess2DIteratorConcept<vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_iterator1,
1622                                             vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_iterator2>::constraints ();
1623        IndexedRandomAccess2DIteratorConcept<vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_reverse_iterator1,
1624                                             vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_reverse_iterator2>::constraints ();
1625
1626        MatrixExpressionConcept<matrix_unary1<matrix<T>, scalar_identity<T> > >::constraints ();
1627        IndexedRandomAccess2DIteratorConcept<matrix_unary1<matrix<T>, scalar_identity<T> >::const_iterator1,
1628                                             matrix_unary1<matrix<T>, scalar_identity<T> >::const_iterator2>::constraints ();
1629        IndexedRandomAccess2DIteratorConcept<matrix_unary1<matrix<T>, scalar_identity<T> >::const_reverse_iterator1,
1630                                             matrix_unary1<matrix<T>, scalar_identity<T> >::const_reverse_iterator2>::constraints ();
1631
1632        MatrixExpressionConcept<matrix_unary2<matrix<T>, scalar_identity<T> > >::constraints ();
1633        IndexedRandomAccess2DIteratorConcept<matrix_unary2<matrix<T>, scalar_identity<T> >::const_iterator1,
1634                                             matrix_unary2<matrix<T>, scalar_identity<T> >::const_iterator2>::constraints ();
1635        IndexedRandomAccess2DIteratorConcept<matrix_unary2<matrix<T>, scalar_identity<T> >::const_reverse_iterator1,
1636                                             matrix_unary2<matrix<T>, scalar_identity<T> >::const_reverse_iterator2>::constraints ();
1637
1638        MatrixExpressionConcept<matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> > >::constraints ();
1639        IndexedRandomAccess2DIteratorConcept<matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_iterator1,
1640                                             matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_iterator2>::constraints ();
1641        IndexedRandomAccess2DIteratorConcept<matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_reverse_iterator1,
1642                                             matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_reverse_iterator2>::constraints ();
1643
1644        MatrixExpressionConcept<matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T> > >::constraints ();
1645        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T> >::const_iterator1,
1646                                             matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T> >::const_iterator2>::constraints ();
1647        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T> >::const_reverse_iterator1,
1648                                             matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T> >::const_reverse_iterator2>::constraints ();
1649
1650        MatrixExpressionConcept<matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T> > >::constraints ();
1651        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T> >::const_iterator1,
1652                                             matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T> >::const_iterator2>::constraints ();
1653        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T> >::const_reverse_iterator1,
1654                                             matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T> >::const_reverse_iterator2>::constraints ();
1655
1656        MatrixExpressionConcept<matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T> > >::constraints ();
1657        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T> >::const_iterator1,
1658                                             matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T> >::const_iterator2>::constraints ();
1659        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T> >::const_reverse_iterator1,
1660                                             matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T> >::const_reverse_iterator2>::constraints ();
1661
1662        MatrixExpressionConcept<matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T> > >::constraints ();
1663        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_iterator1,
1664                                             matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_iterator2>::constraints ();
1665        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_reverse_iterator1,
1666                                             matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T> >::const_reverse_iterator2>::constraints ();
1667
1668        VectorExpressionConcept<matrix_vector_binary1<matrix<T>, vector<T>, matrix_vector_prod1<T, T, T> > >::constraints ();
1669        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary1<matrix<T>, vector<T>, matrix_vector_prod1<T, T, T> >::const_iterator>::constraints ();
1670        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary1<matrix<T>, vector<T>, matrix_vector_prod1<T, T, T> >::const_reverse_iterator>::constraints ();
1671
1672        VectorExpressionConcept<matrix_vector_binary2<vector<T>, matrix<T>, matrix_vector_prod2<T, T, T> > >::constraints ();
1673        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary2<vector<T>, matrix<T>, matrix_vector_prod2<T, T, T> >::const_iterator>::constraints ();
1674        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary2<vector<T>, matrix<T>, matrix_vector_prod2<T, T, T> >::const_reverse_iterator>::constraints ();
1675
1676        MatrixExpressionConcept<matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> > >::constraints ();
1677        IndexedRandomAccess2DIteratorConcept<matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_iterator1,
1678                                             matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_iterator2>::constraints ();
1679        IndexedRandomAccess2DIteratorConcept<matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_reverse_iterator1,
1680                                             matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_reverse_iterator2>::constraints ();
1681
1682        ScalarExpressionConcept<matrix_scalar_unary<matrix<T>, matrix_norm_1<T> > >::constraints ();
1683        ScalarExpressionConcept<matrix_scalar_unary<matrix<T>, matrix_norm_frobenius<T> > >::constraints ();
1684        ScalarExpressionConcept<matrix_scalar_unary<matrix<T>, matrix_norm_inf<T> > >::constraints ();
1685#endif
1686
1687#ifdef EXTERNAL
1688        AdditiveAbelianGroupConcept<float>::constraints ();
1689        CommutativeRingWithIdentityConcept<float>::constraints ();
1690        FieldConcept<float>::constraints ();
1691        VectorSpaceConcept<float, vector<float> >::constraints ();
1692        RingWithIdentityConcept<matrix<float> >::constraints (0);
1693        VectorSpaceConcept<float, matrix<float> >::constraints ();
1694        LinearOperatorConcept<float, vector<float>, matrix<float> >::constraints ();
1695
1696        AdditiveAbelianGroupConcept<double>::constraints ();
1697        CommutativeRingWithIdentityConcept<double>::constraints ();
1698        FieldConcept<double>::constraints ();
1699        VectorSpaceConcept<double, vector<double> >::constraints ();
1700        RingWithIdentityConcept<matrix<double> >::constraints (0);
1701        VectorSpaceConcept<double, matrix<double> >::constraints ();
1702        LinearOperatorConcept<double, vector<double>, matrix<double> >::constraints ();
1703
1704        AdditiveAbelianGroupConcept<std::complex<float> >::constraints ();
1705        CommutativeRingWithIdentityConcept<std::complex<float> >::constraints ();
1706        FieldConcept<std::complex<float> >::constraints ();
1707        VectorSpaceConcept<std::complex<float>, vector<std::complex<float> > >::constraints ();
1708        RingWithIdentityConcept<matrix<std::complex<float> > >::constraints (0);
1709        VectorSpaceConcept<std::complex<float>, matrix<std::complex<float> > >::constraints ();
1710        LinearOperatorConcept<std::complex<float>, vector<std::complex<float> >, matrix<std::complex<float> > >::constraints ();
1711
1712        AdditiveAbelianGroupConcept<std::complex<double> >::constraints ();
1713        CommutativeRingWithIdentityConcept<std::complex<double> >::constraints ();
1714        FieldConcept<std::complex<double> >::constraints ();
1715        VectorSpaceConcept<std::complex<double>, vector<std::complex<double> > >::constraints ();
1716        RingWithIdentityConcept<matrix<std::complex<double> > >::constraints (0);
1717        VectorSpaceConcept<std::complex<double>, matrix<std::complex<double> > >::constraints ();
1718        LinearOperatorConcept<std::complex<double>, vector<std::complex<double> >, matrix<std::complex<double> > >::constraints ();
1719#endif
1720    }
1721
1722}}}
1723
1724#endif
Note: See TracBrowser for help on using the repository browser.