From 97a2d302a97f75e49cf1101df4b07625f36c9cb0 Mon Sep 17 00:00:00 2001
From: Michael Stevens <mail@michael-stevens.de>
Date: Mon, 14 Mar 2005 13:46:00 +0000
Subject: [PATCH] Indivitual INTERNAL tests to reduce compilation size Use
 typedef float T

svn path=/trunk/boost/boost/numeric/ublas/; revision=27645
---
 .../boost/numeric/ublas/detail/concepts.hpp   | 773 +++++++++---------
 1 file changed, 393 insertions(+), 380 deletions(-)

diff --git a/include/boost/numeric/ublas/detail/concepts.hpp b/include/boost/numeric/ublas/detail/concepts.hpp
index 9096de69..9c57f5d7 100644
--- a/include/boost/numeric/ublas/detail/concepts.hpp
+++ b/include/boost/numeric/ublas/detail/concepts.hpp
@@ -1138,27 +1138,40 @@ namespace boost { namespace numeric { namespace ublas {
 
     void concept_checks () {
 
+		// Allow tests to be group to keep down compiler storage requirement
+#ifdef INTERAL
+#define INTERNAL_STORAGE
+#define INTERNAL_VECTOR
+#define INTERNAL_MATRIX
+#define INTERNAL_SPECIAL
+#define INTERNAL_SPARSE
+#define INTERNAL_EXPRESSION
+#endif
+
+		// Element value type for tests
+		typedef float T;
+
         // Storage Array
-#if defined (INTERNAL) || defined (INTERNAL_STORAGE)
-        StorageArrayConcept<const std::vector<double> >::constraints ();
-        MutableStorageArrayConcept<std::vector<double> >::constraints ();
-        RandomAccessIteratorConcept<std::vector<double>::const_iterator>::constraints ();
-        MutableRandomAccessIteratorConcept<std::vector<double>::iterator>::constraints ();
+#if defined (INTERNAL_STORAGE) || defined (INTERNAL_STORAGE_DENSE)
+        StorageArrayConcept<const std::vector<T> >::constraints ();
+        MutableStorageArrayConcept<std::vector<T> >::constraints ();
+        RandomAccessIteratorConcept<std::vector<T>::const_iterator>::constraints ();
+        MutableRandomAccessIteratorConcept<std::vector<T>::iterator>::constraints ();
 
-        StorageArrayConcept<const bounded_array<double, 1> >::constraints ();
-        MutableStorageArrayConcept<bounded_array<double, 1> >::constraints ();
-        RandomAccessIteratorConcept<bounded_array<double, 1>::const_iterator>::constraints ();
-        MutableRandomAccessIteratorConcept<bounded_array<double, 1>::iterator>::constraints ();
+        StorageArrayConcept<const bounded_array<T, 1> >::constraints ();
+        MutableStorageArrayConcept<bounded_array<T, 1> >::constraints ();
+        RandomAccessIteratorConcept<bounded_array<T, 1>::const_iterator>::constraints ();
+        MutableRandomAccessIteratorConcept<bounded_array<T, 1>::iterator>::constraints ();
 
-        StorageArrayConcept<const unbounded_array<double> >::constraints ();
-        MutableStorageArrayConcept<unbounded_array<double> >::constraints ();
-        RandomAccessIteratorConcept<unbounded_array<double>::const_iterator>::constraints ();
-        MutableRandomAccessIteratorConcept<unbounded_array<double>::iterator>::constraints ();
+        StorageArrayConcept<const unbounded_array<T> >::constraints ();
+        MutableStorageArrayConcept<unbounded_array<T> >::constraints ();
+        RandomAccessIteratorConcept<unbounded_array<T>::const_iterator>::constraints ();
+        MutableRandomAccessIteratorConcept<unbounded_array<T>::iterator>::constraints ();
 
-        StorageArrayConcept<const array_adaptor<double> >::constraints ();
-        MutableStorageArrayConcept<array_adaptor<double> >::constraints ();
-        RandomAccessIteratorConcept<array_adaptor<double>::const_iterator>::constraints ();
-        MutableRandomAccessIteratorConcept<array_adaptor<double>::iterator>::constraints ();
+        StorageArrayConcept<const array_adaptor<T> >::constraints ();
+        MutableStorageArrayConcept<array_adaptor<T> >::constraints ();
+        RandomAccessIteratorConcept<array_adaptor<T>::const_iterator>::constraints ();
+        MutableRandomAccessIteratorConcept<array_adaptor<T>::iterator>::constraints ();
 
         IndexSetConcept<range>::constraints ();
         RandomAccessIteratorConcept<range::const_iterator>::constraints ();
@@ -1171,331 +1184,331 @@ namespace boost { namespace numeric { namespace ublas {
 #endif
 
         // Storage Sparse
-#if defined (INTERNAL) || defined (INTERNAL_STORAGE_SPARSE)
-        StorageSparseConcept<const map_array<std::size_t, double> >::constraints ();
-        MutableStorageSparseConcept<map_array<std::size_t, double> >::constraints ();
-        RandomAccessIteratorConcept<map_array<std::size_t, double>::const_iterator>::constraints ();
-        MutableRandomAccessIteratorConcept<map_array<std::size_t, double>::iterator>::constraints ();
+#if defined (INTERNAL_STORAGE) || defined (INTERNAL_STORAGE_SPARSE)
+        StorageSparseConcept<const map_array<std::size_t, T> >::constraints ();
+        MutableStorageSparseConcept<map_array<std::size_t, T> >::constraints ();
+        RandomAccessIteratorConcept<map_array<std::size_t, T>::const_iterator>::constraints ();
+        MutableRandomAccessIteratorConcept<map_array<std::size_t, T>::iterator>::constraints ();
 
-        StorageSparseConcept<const std::map<std::size_t, double> >::constraints ();
-        MutableStorageSparseConcept<std::map<std::size_t, double> >::constraints ();
-        BidirectionalIteratorConcept<std::map<std::size_t, double>::const_iterator>::constraints ();
+        StorageSparseConcept<const std::map<std::size_t, T> >::constraints ();
+        MutableStorageSparseConcept<std::map<std::size_t, T> >::constraints ();
+        BidirectionalIteratorConcept<std::map<std::size_t, T>::const_iterator>::constraints ();
                 // Not value_type mutable
-        BidirectionalIteratorConcept<std::map<std::size_t, double>::iterator>::constraints ();
+        BidirectionalIteratorConcept<std::map<std::size_t, T>::iterator>::constraints ();
 #endif
 
         // Vector
-#if defined (INTERNAL) || defined (INTERNAL_VECTOR)
-        VectorConcept<const vector<double> >::constraints ();
-        MutableVectorConcept<vector<double> >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector<double>::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector<double>::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector<double>::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector<double>::reverse_iterator>::constraints ();
+#if defined (INTERNAL_VECTOR) || defined (INTERNAL_VECTOR_DENSE)
+        VectorConcept<const vector<T> >::constraints ();
+        MutableVectorConcept<vector<T> >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector<T>::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector<T>::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector<T>::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector<T>::reverse_iterator>::constraints ();
 
-        VectorConcept<zero_vector<double> >::constraints ();
-        IndexedBidirectional1DIteratorConcept<zero_vector<double>::const_iterator>::constraints ();
-        IndexedBidirectional1DIteratorConcept<zero_vector<double>::const_reverse_iterator>::constraints ();
+        VectorConcept<zero_vector<T> >::constraints ();
+        IndexedBidirectional1DIteratorConcept<zero_vector<T>::const_iterator>::constraints ();
+        IndexedBidirectional1DIteratorConcept<zero_vector<T>::const_reverse_iterator>::constraints ();
 
-        VectorConcept<unit_vector<double> >::constraints ();
-        IndexedBidirectional1DIteratorConcept<unit_vector<double>::const_iterator>::constraints ();
-        IndexedBidirectional1DIteratorConcept<unit_vector<double>::const_reverse_iterator>::constraints ();
+        VectorConcept<unit_vector<T> >::constraints ();
+        IndexedBidirectional1DIteratorConcept<unit_vector<T>::const_iterator>::constraints ();
+        IndexedBidirectional1DIteratorConcept<unit_vector<T>::const_reverse_iterator>::constraints ();
 
-        VectorConcept<scalar_vector<double> >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<scalar_vector<double>::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<scalar_vector<double>::const_reverse_iterator>::constraints ();
+        VectorConcept<scalar_vector<T> >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<scalar_vector<T>::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<scalar_vector<T>::const_reverse_iterator>::constraints ();
 
-        VectorConcept<const c_vector<double, 1> >::constraints ();
-        MutableVectorConcept<c_vector<double, 1> >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::reverse_iterator>::constraints ();
+        VectorConcept<const c_vector<T, 1> >::constraints ();
+        MutableVectorConcept<c_vector<T, 1> >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<c_vector<T, 1>::reverse_iterator>::constraints ();
 #endif
 
         // Vector Proxies
-#if defined (INTERNAL) || defined (INTERNAL_VECTOR_PROXY)
-        VectorExpressionConcept<const vector_range<const vector<double> > >::constraints ();
-        MutableVectorExpressionConcept<vector_range<vector<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::reverse_iterator>::constraints ();
+#if defined (INTERNAL_VECTOR) || defined (INTERNAL_VECTOR_PROXY)
+        VectorExpressionConcept<const vector_range<const vector<T> > >::constraints ();
+        MutableVectorExpressionConcept<vector_range<vector<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<const vector_slice<const vector<double> > >::constraints ();
-        MutableVectorExpressionConcept<vector_slice<vector<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<const vector_slice<const vector<T> > >::constraints ();
+        MutableVectorExpressionConcept<vector_slice<vector<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<const vector_indirect<const vector<double> > >::constraints ();
-        MutableVectorExpressionConcept<vector_indirect<vector<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<const vector_indirect<const vector<T> > >::constraints ();
+        MutableVectorExpressionConcept<vector_indirect<vector<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<T> >::reverse_iterator>::constraints ();
 #endif
 
         // Sparse Vector
-#if defined (INTERNAL) || defined (INTERNAL_VECTOR_SPARSE)
-        SparseVectorConcept<const mapped_vector<double> >::constraints ();
-        MutableSparseVectorConcept<mapped_vector<double> >::constraints ();
-        IndexedBidirectional1DIteratorConcept<mapped_vector<double>::const_iterator>::constraints ();
-        MutableIndexedBidirectional1DIteratorConcept<mapped_vector<double>::iterator>::constraints ();
-        IndexedBidirectional1DIteratorConcept<mapped_vector<double>::const_reverse_iterator>::constraints ();
-        MutableIndexedBidirectional1DIteratorConcept<mapped_vector<double>::reverse_iterator>::constraints ();
+#if defined (INTERNAL_SPARSE) || defined (INTERNAL_VECTOR_SPARSE)
+        SparseVectorConcept<const mapped_vector<T> >::constraints ();
+        MutableSparseVectorConcept<mapped_vector<T> >::constraints ();
+        IndexedBidirectional1DIteratorConcept<mapped_vector<T>::const_iterator>::constraints ();
+        MutableIndexedBidirectional1DIteratorConcept<mapped_vector<T>::iterator>::constraints ();
+        IndexedBidirectional1DIteratorConcept<mapped_vector<T>::const_reverse_iterator>::constraints ();
+        MutableIndexedBidirectional1DIteratorConcept<mapped_vector<T>::reverse_iterator>::constraints ();
 
-        SparseVectorConcept<const compressed_vector<double> >::constraints ();
-        MutableSparseVectorConcept<compressed_vector<double> >::constraints ();
-        IndexedBidirectional1DIteratorConcept<compressed_vector<double>::const_iterator>::constraints ();
-        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<double>::iterator>::constraints ();
-        IndexedBidirectional1DIteratorConcept<compressed_vector<double>::const_reverse_iterator>::constraints ();
-        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<double>::reverse_iterator>::constraints ();
+        SparseVectorConcept<const compressed_vector<T> >::constraints ();
+        MutableSparseVectorConcept<compressed_vector<T> >::constraints ();
+        IndexedBidirectional1DIteratorConcept<compressed_vector<T>::const_iterator>::constraints ();
+        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<T>::iterator>::constraints ();
+        IndexedBidirectional1DIteratorConcept<compressed_vector<T>::const_reverse_iterator>::constraints ();
+        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<T>::reverse_iterator>::constraints ();
 
-        SparseVectorConcept<const coordinate_vector<double> >::constraints ();
-        MutableSparseVectorConcept<coordinate_vector<double> >::constraints ();
-        IndexedBidirectional1DIteratorConcept<coordinate_vector<double>::const_iterator>::constraints ();
-        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<double>::iterator>::constraints ();
-        IndexedBidirectional1DIteratorConcept<coordinate_vector<double>::const_reverse_iterator>::constraints ();
-        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<double>::reverse_iterator>::constraints ();
+        SparseVectorConcept<const coordinate_vector<T> >::constraints ();
+        MutableSparseVectorConcept<coordinate_vector<T> >::constraints ();
+        IndexedBidirectional1DIteratorConcept<coordinate_vector<T>::const_iterator>::constraints ();
+        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<T>::iterator>::constraints ();
+        IndexedBidirectional1DIteratorConcept<coordinate_vector<T>::const_reverse_iterator>::constraints ();
+        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<T>::reverse_iterator>::constraints ();
 #endif
 
         // Matrix
-#if defined (INTERNAL) || defined (INTERNAL_MATRIX)
-        MatrixConcept<const matrix<double> >::constraints ();
-        MutableMatrixConcept<matrix<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix<double>::const_iterator1,
-                                             matrix<double>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix<double>::iterator1,
-                                                    matrix<double>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix<double>::const_reverse_iterator1,
-                                             matrix<double>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix<double>::reverse_iterator1,
-                                                    matrix<double>::reverse_iterator2>::constraints ();
+#if defined (INTERNAL_MATRIX) || defined (INTERNAL_MATRIX_DENSE)
+        MatrixConcept<const matrix<T> >::constraints ();
+        MutableMatrixConcept<matrix<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix<T>::const_iterator1,
+                                             matrix<T>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix<T>::iterator1,
+                                                    matrix<T>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix<T>::const_reverse_iterator1,
+                                             matrix<T>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix<T>::reverse_iterator1,
+                                                    matrix<T>::reverse_iterator2>::constraints ();
 
-        MatrixConcept<const vector_of_vector<double> >::constraints ();
-        MutableMatrixConcept<vector_of_vector<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::const_iterator1,
-                                             vector_of_vector<double>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::iterator1,
-                                                    vector_of_vector<double>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::const_reverse_iterator1,
-                                             vector_of_vector<double>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::reverse_iterator1,
-                                                    vector_of_vector<double>::reverse_iterator2>::constraints ();
+        MatrixConcept<const vector_of_vector<T> >::constraints ();
+        MutableMatrixConcept<vector_of_vector<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::const_iterator1,
+                                             vector_of_vector<T>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::iterator1,
+                                                    vector_of_vector<T>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::const_reverse_iterator1,
+                                             vector_of_vector<T>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<T>::reverse_iterator1,
+                                                    vector_of_vector<T>::reverse_iterator2>::constraints ();
 
-        MatrixConcept<zero_matrix<double> >::constraints ();
-        IndexedBidirectional2DIteratorConcept<zero_matrix<double>::const_iterator1,
-                                              zero_matrix<double>::const_iterator2>::constraints ();
-        IndexedBidirectional2DIteratorConcept<zero_matrix<double>::const_reverse_iterator1,
-                                              zero_matrix<double>::const_reverse_iterator2>::constraints ();
+        MatrixConcept<zero_matrix<T> >::constraints ();
+        IndexedBidirectional2DIteratorConcept<zero_matrix<T>::const_iterator1,
+                                              zero_matrix<T>::const_iterator2>::constraints ();
+        IndexedBidirectional2DIteratorConcept<zero_matrix<T>::const_reverse_iterator1,
+                                              zero_matrix<T>::const_reverse_iterator2>::constraints ();
 
-        MatrixConcept<identity_matrix<double> >::constraints ();
-        IndexedBidirectional2DIteratorConcept<identity_matrix<double>::const_iterator1,
-                                             identity_matrix<double>::const_iterator2>::constraints ();
-        IndexedBidirectional2DIteratorConcept<identity_matrix<double>::const_reverse_iterator1,
-                                             identity_matrix<double>::const_reverse_iterator2>::constraints ();
+        MatrixConcept<identity_matrix<T> >::constraints ();
+        IndexedBidirectional2DIteratorConcept<identity_matrix<T>::const_iterator1,
+                                             identity_matrix<T>::const_iterator2>::constraints ();
+        IndexedBidirectional2DIteratorConcept<identity_matrix<T>::const_reverse_iterator1,
+                                             identity_matrix<T>::const_reverse_iterator2>::constraints ();
 
-        MatrixConcept<scalar_matrix<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<scalar_matrix<double>::const_iterator1,
-                                             scalar_matrix<double>::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<scalar_matrix<double>::const_reverse_iterator1,
-                                             scalar_matrix<double>::const_reverse_iterator2>::constraints ();
+        MatrixConcept<scalar_matrix<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<scalar_matrix<T>::const_iterator1,
+                                             scalar_matrix<T>::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<scalar_matrix<T>::const_reverse_iterator1,
+                                             scalar_matrix<T>::const_reverse_iterator2>::constraints ();
 
-        MatrixConcept<const c_matrix<double, 1, 1> >::constraints ();
-        MutableMatrixConcept<c_matrix<double, 1, 1> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::const_iterator1,
-                                             c_matrix<double, 1, 1>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::iterator1,
-                                                    c_matrix<double, 1, 1>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::const_reverse_iterator1,
-                                             c_matrix<double, 1, 1>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::reverse_iterator1,
-                                                    c_matrix<double, 1, 1>::reverse_iterator2>::constraints ();
+        MatrixConcept<const c_matrix<T, 1, 1> >::constraints ();
+        MutableMatrixConcept<c_matrix<T, 1, 1> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::const_iterator1,
+                                             c_matrix<T, 1, 1>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::iterator1,
+                                                    c_matrix<T, 1, 1>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::const_reverse_iterator1,
+                                             c_matrix<T, 1, 1>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<T, 1, 1>::reverse_iterator1,
+                                                    c_matrix<T, 1, 1>::reverse_iterator2>::constraints ();
 #endif
 
         // Matrix Proxies
-#if defined (INTERNAL) || defined (INTERNAL_MATRIX_PROXY)
-        VectorExpressionConcept<const matrix_row<const matrix<double> > >::constraints ();
-        MutableVectorExpressionConcept<matrix_row<matrix<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::reverse_iterator>::constraints ();
+#if defined (INTERNAL_MATRIX) || defined (INTERNAL_MATRIX_PROXY)
+        VectorExpressionConcept<const matrix_row<const matrix<T> > >::constraints ();
+        MutableVectorExpressionConcept<matrix_row<matrix<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<const matrix_column<const matrix<double> > >::constraints ();
-        MutableVectorExpressionConcept<matrix_column<matrix<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<const matrix_column<const matrix<T> > >::constraints ();
+        MutableVectorExpressionConcept<matrix_column<matrix<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<const matrix_vector_range<const matrix<double> > >::constraints ();
-        MutableVectorExpressionConcept<matrix_vector_range<matrix<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<const matrix_vector_range<const matrix<T> > >::constraints ();
+        MutableVectorExpressionConcept<matrix_vector_range<matrix<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<const matrix_vector_slice<const matrix<double> > >::constraints ();
-        MutableVectorExpressionConcept<matrix_vector_slice<matrix<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<const matrix_vector_slice<const matrix<T> > >::constraints ();
+        MutableVectorExpressionConcept<matrix_vector_slice<matrix<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<const matrix_vector_indirect<const matrix<double>, vector<unsigned> > >::constraints ();
-        MutableVectorExpressionConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<const matrix_vector_indirect<const matrix<T>, vector<unsigned> > >::constraints ();
+        MutableVectorExpressionConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<T>, vector<unsigned> >::reverse_iterator>::constraints ();
 
-        MatrixExpressionConcept<const matrix_range<const matrix<double> > >::constraints ();
-        MutableMatrixExpressionConcept<matrix_range<matrix<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::const_iterator1,
-                                             matrix_range<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::iterator1,
-                                                    matrix_range<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::const_reverse_iterator1,
-                                             matrix_range<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::reverse_iterator1,
-                                                    matrix_range<matrix<double> >::reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<const matrix_range<const matrix<T> > >::constraints ();
+        MutableMatrixExpressionConcept<matrix_range<matrix<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::const_iterator1,
+                                             matrix_range<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::iterator1,
+                                                    matrix_range<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::const_reverse_iterator1,
+                                             matrix_range<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<T> >::reverse_iterator1,
+                                                    matrix_range<matrix<T> >::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<const matrix_slice<const matrix<double> > >::constraints ();
-        MutableMatrixExpressionConcept<matrix_slice<matrix<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::const_iterator1,
-                                             matrix_slice<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::iterator1,
-                                                    matrix_slice<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::const_reverse_iterator1,
-                                             matrix_slice<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::reverse_iterator1,
-                                                    matrix_slice<matrix<double> >::reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<const matrix_slice<const matrix<T> > >::constraints ();
+        MutableMatrixExpressionConcept<matrix_slice<matrix<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::const_iterator1,
+                                             matrix_slice<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::iterator1,
+                                                    matrix_slice<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::const_reverse_iterator1,
+                                             matrix_slice<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<T> >::reverse_iterator1,
+                                                    matrix_slice<matrix<T> >::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<const matrix_indirect<const matrix<double> > >::constraints ();
-        MutableMatrixExpressionConcept<matrix_indirect<matrix<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::const_iterator1,
-                                             matrix_indirect<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::iterator1,
-                                                    matrix_indirect<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::const_reverse_iterator1,
-                                             matrix_indirect<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::reverse_iterator1,
-                                                    matrix_indirect<matrix<double> >::reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<const matrix_indirect<const matrix<T> > >::constraints ();
+        MutableMatrixExpressionConcept<matrix_indirect<matrix<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::const_iterator1,
+                                             matrix_indirect<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::iterator1,
+                                                    matrix_indirect<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::const_reverse_iterator1,
+                                             matrix_indirect<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<T> >::reverse_iterator1,
+                                                    matrix_indirect<matrix<T> >::reverse_iterator2>::constraints ();
 #endif
 
         // Banded Matrix
-#if defined (INTERNAL) || defined (INTERNAL_BANDED)
-        MatrixConcept<const banded_matrix<double> >::constraints ();
-        MutableMatrixConcept<banded_matrix<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<banded_matrix<double>::const_iterator1,
-                                             banded_matrix<double>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<double>::iterator1,
-                                                    banded_matrix<double>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<banded_matrix<double>::const_reverse_iterator1,
-                                             banded_matrix<double>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<double>::reverse_iterator1,
-                                                    banded_matrix<double>::reverse_iterator2>::constraints ();
+#if defined (INTERNAL_SPECIAL) || defined (INTERNAL_BANDED)
+        MatrixConcept<const banded_matrix<T> >::constraints ();
+        MutableMatrixConcept<banded_matrix<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<banded_matrix<T>::const_iterator1,
+                                             banded_matrix<T>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<T>::iterator1,
+                                                    banded_matrix<T>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<banded_matrix<T>::const_reverse_iterator1,
+                                             banded_matrix<T>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<T>::reverse_iterator1,
+                                                    banded_matrix<T>::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<const banded_adaptor<const matrix<double> > >::constraints ();
-        MutableMatrixExpressionConcept<banded_adaptor<matrix<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::const_iterator1,
-                                             banded_adaptor<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::iterator1,
-                                                    banded_adaptor<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::const_reverse_iterator1,
-                                             banded_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::reverse_iterator1,
-                                                    banded_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<const banded_adaptor<const matrix<T> > >::constraints ();
+        MutableMatrixExpressionConcept<banded_adaptor<matrix<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::const_iterator1,
+                                             banded_adaptor<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::iterator1,
+                                                    banded_adaptor<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::const_reverse_iterator1,
+                                             banded_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<T> >::reverse_iterator1,
+                                                    banded_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
 #endif
 
         // Triangular Matrix
-#if defined (INTERNAL) || defined (INTERNAL_TRIANGULAR)
-        MatrixConcept<const triangular_matrix<double> >::constraints ();
-        MutableMatrixConcept<triangular_matrix<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::const_iterator1,
-                                             triangular_matrix<double>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::iterator1,
-                                                    triangular_matrix<double>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::const_reverse_iterator1,
-                                             triangular_matrix<double>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::reverse_iterator1,
-                                                    triangular_matrix<double>::reverse_iterator2>::constraints ();
+#if defined (INTERNAL_SPECIAL) || defined (INTERNAL_TRIANGULAR)
+        MatrixConcept<const triangular_matrix<T> >::constraints ();
+        MutableMatrixConcept<triangular_matrix<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::const_iterator1,
+                                             triangular_matrix<T>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::iterator1,
+                                                    triangular_matrix<T>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::const_reverse_iterator1,
+                                             triangular_matrix<T>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<T>::reverse_iterator1,
+                                                    triangular_matrix<T>::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<const triangular_adaptor<const matrix<double> > >::constraints ();
-        MutableMatrixExpressionConcept<triangular_adaptor<matrix<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::const_iterator1,
-                                             triangular_adaptor<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::iterator1,
-                                                    triangular_adaptor<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::const_reverse_iterator1,
-                                             triangular_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::reverse_iterator1,
-                                                    triangular_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<const triangular_adaptor<const matrix<T> > >::constraints ();
+        MutableMatrixExpressionConcept<triangular_adaptor<matrix<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::const_iterator1,
+                                             triangular_adaptor<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::iterator1,
+                                                    triangular_adaptor<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::const_reverse_iterator1,
+                                             triangular_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<T> >::reverse_iterator1,
+                                                    triangular_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
 #endif
 
         // Symmetric Matrix
-#if defined (INTERNAL) || defined (INTERNAL_SYMMETRIC)
-        MatrixConcept<const symmetric_matrix<double> >::constraints ();
-        MutableMatrixConcept<symmetric_matrix<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::const_iterator1,
-                                             symmetric_matrix<double>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::iterator1,
-                                                    symmetric_matrix<double>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::const_reverse_iterator1,
-                                             symmetric_matrix<double>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::reverse_iterator1,
-                                                    symmetric_matrix<double>::reverse_iterator2>::constraints ();
+#if defined (INTERNA_SPECIAL) || defined (INTERNAL_SYMMETRIC)
+        MatrixConcept<const symmetric_matrix<T> >::constraints ();
+        MutableMatrixConcept<symmetric_matrix<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::const_iterator1,
+                                             symmetric_matrix<T>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::iterator1,
+                                                    symmetric_matrix<T>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::const_reverse_iterator1,
+                                             symmetric_matrix<T>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<T>::reverse_iterator1,
+                                                    symmetric_matrix<T>::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<const symmetric_adaptor<const matrix<double> > >::constraints ();
+        MatrixExpressionConcept<const symmetric_adaptor<const matrix<T> > >::constraints ();
 #ifndef SKIP_BAD
         // const_iterator (iterator) constructor is bad
-        MutableMatrixExpressionConcept<symmetric_adaptor<matrix<double> > >::constraints ();
+        MutableMatrixExpressionConcept<symmetric_adaptor<matrix<T> > >::constraints ();
 #endif
-        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::const_iterator1,
-                                             symmetric_adaptor<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::iterator1,
-                                                    symmetric_adaptor<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::const_reverse_iterator1,
-                                             symmetric_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::reverse_iterator1,
-                                                    symmetric_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::const_iterator1,
+                                             symmetric_adaptor<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::iterator1,
+                                                    symmetric_adaptor<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::const_reverse_iterator1,
+                                             symmetric_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<T> >::reverse_iterator1,
+                                                    symmetric_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
 #endif
 
         // Hermitian Matrix
-#if defined (INTERNAL) || defined (INTERNAL_HERMITIAN)
-        MatrixConcept<const hermitian_matrix<double> >::constraints ();
-        MutableMatrixConcept<hermitian_matrix<double> >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::const_iterator1,
-                                             hermitian_matrix<double>::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::iterator1,
-                                                    hermitian_matrix<double>::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::const_reverse_iterator1,
-                                             hermitian_matrix<double>::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::reverse_iterator1,
-                                                    hermitian_matrix<double>::reverse_iterator2>::constraints ();
+#if defined (INTERNAL_SPECIAL) || defined (INTERNAL_HERMITIAN)
+        MatrixConcept<const hermitian_matrix<T> >::constraints ();
+        MutableMatrixConcept<hermitian_matrix<T> >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::const_iterator1,
+                                             hermitian_matrix<T>::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::iterator1,
+                                                    hermitian_matrix<T>::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::const_reverse_iterator1,
+                                             hermitian_matrix<T>::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<T>::reverse_iterator1,
+                                                    hermitian_matrix<T>::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<const hermitian_adaptor<const matrix<double> > >::constraints ();
+        MatrixExpressionConcept<const hermitian_adaptor<const matrix<T> > >::constraints ();
 #ifndef SKIP_BAD
         // const_iterator (iterator) constructor is bad
-        MutableMatrixExpressionConcept<hermitian_adaptor<matrix<double> > >::constraints ();
+        MutableMatrixExpressionConcept<hermitian_adaptor<matrix<T> > >::constraints ();
 #endif
-        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::const_iterator1,
-                                             hermitian_adaptor<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::iterator1,
-                                                    hermitian_adaptor<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::const_reverse_iterator1,
-                                             hermitian_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::reverse_iterator1,
-                                                    hermitian_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::const_iterator1,
+                                             hermitian_adaptor<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::iterator1,
+                                                    hermitian_adaptor<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::const_reverse_iterator1,
+                                             hermitian_adaptor<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<T> >::reverse_iterator1,
+                                                    hermitian_adaptor<matrix<T> >::reverse_iterator2>::constraints ();
 #endif
 
         // Sparse Matrix
-#if defined (INTERNAL) || defined (INTERNAL_MATRIX_SPARSE)
+#if defined (INTERNAL_SPARSE) || defined (INTERNAL_MATRIX_SPARSE)
         {
-            typedef mapped_matrix<double> container_model;
+            typedef mapped_matrix<T> container_model;
             SparseMatrixConcept<const container_model>::constraints ();
             MutableSparseMatrixConcept<container_model>::constraints ();
             IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
@@ -1504,7 +1517,7 @@ namespace boost { namespace numeric { namespace ublas {
             MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
         }
         {
-            typedef mapped_vector_of_mapped_vector<double> container_model;
+            typedef mapped_vector_of_mapped_vector<T> container_model;
             SparseMatrixConcept<const container_model>::constraints ();
             MutableSparseMatrixConcept<container_model>::constraints ();
             IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
@@ -1513,7 +1526,7 @@ namespace boost { namespace numeric { namespace ublas {
             MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
         }
         {
-            typedef compressed_matrix<double> container_model;
+            typedef compressed_matrix<T> container_model;
             SparseMatrixConcept<const container_model>::constraints ();
             MutableSparseMatrixConcept<container_model>::constraints ();
             IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
@@ -1522,7 +1535,7 @@ namespace boost { namespace numeric { namespace ublas {
             MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
         }
         {
-            typedef coordinate_matrix<double> container_model;
+            typedef coordinate_matrix<T> container_model;
             SparseMatrixConcept<const container_model>::constraints ();
             MutableSparseMatrixConcept<container_model>::constraints ();
             IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
@@ -1531,7 +1544,7 @@ namespace boost { namespace numeric { namespace ublas {
             MutableIndexedBidirectional2DIteratorConcept<container_model::reverse_iterator1, container_model::reverse_iterator2>::constraints ();
         }
         {
-            typedef generalized_vector_of_vector<double, row_major, vector< coordinate_vector<double> > > container_model;
+            typedef generalized_vector_of_vector<T, row_major, vector< coordinate_vector<T> > > container_model;
             SparseMatrixConcept<const container_model>::constraints ();
             MutableSparseMatrixConcept<container_model>::constraints ();
             IndexedBidirectional2DIteratorConcept<container_model::const_iterator1, container_model::const_iterator2>::constraints ();
@@ -1543,128 +1556,128 @@ namespace boost { namespace numeric { namespace ublas {
 #endif
 
         // Scalar Expressions
-#if defined (INTERNAL) || defined (INTERNAL_VECTOR_EXPRESSION)
-        ScalarExpressionConcept<scalar_value<double > >::constraints ();
-        ScalarExpressionConcept<scalar_reference<double > >::constraints ();
+#if defined (INTERNAL_EXPRESSION) || defined (INTERNAL_VECTOR_EXPRESSION)
+        ScalarExpressionConcept<scalar_value<T > >::constraints ();
+        ScalarExpressionConcept<scalar_reference<T > >::constraints ();
 
         // Vector Expressions
-        VectorExpressionConcept<vector_reference<vector<double> > >::constraints ();
-        MutableVectorExpressionConcept<vector_reference<vector<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_reference<vector<double> >::const_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_reference<vector<double> >::iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_reference<vector<double> >::const_reverse_iterator>::constraints ();
-        MutableIndexedRandomAccess1DIteratorConcept<vector_reference<vector<double> >::reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_reference<vector<T> > >::constraints ();
+        MutableVectorExpressionConcept<vector_reference<vector<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::const_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::const_reverse_iterator>::constraints ();
+        MutableIndexedRandomAccess1DIteratorConcept<vector_reference<vector<T> >::reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<vector_unary<vector<double>, scalar_identity<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_unary<vector<double>, scalar_identity<double>  >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_unary<vector<double>, scalar_identity<double>  >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_unary<vector<T>, scalar_identity<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_unary<vector<T>, scalar_identity<T>  >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_unary<vector<T>, scalar_identity<T>  >::const_reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<vector_binary<vector<double>, vector<double>, scalar_plus<double, double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary<vector<double>, vector<double>, scalar_plus<double, double> >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary<vector<double>, vector<double>, scalar_plus<double, double> >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_binary<vector<T>, vector<T>, scalar_plus<T, T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary<vector<T>, vector<T>, scalar_plus<T, T> >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary<vector<T>, vector<T>, scalar_plus<T, T> >::const_reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<vector_binary_scalar1<double, vector<double>, scalar_multiplies<double, double>, scalar_reference<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<double, vector<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<double, vector<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_binary_scalar1<T, vector<T>, scalar_multiplies<T, T>, scalar_reference<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<T, vector<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<T, vector<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<vector_binary_scalar2<vector<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<vector_binary_scalar1<scalar_value<double>, vector<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<scalar_value<double>, vector<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<scalar_value<double>, vector<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_binary_scalar1<scalar_value<T>, vector<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<scalar_value<T>, vector<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar1<scalar_value<T>, vector<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<vector_binary_scalar2<vector<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<vector_binary_scalar2<vector<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_reverse_iterator>::constraints ();
 
-        ScalarExpressionConcept<vector_scalar_unary<vector<double>, vector_sum<double> > >::constraints ();
-        ScalarExpressionConcept<vector_scalar_unary<vector<double>, vector_norm_1<double> > >::constraints ();
-        ScalarExpressionConcept<vector_scalar_unary<vector<double>, vector_norm_2<double> > >::constraints ();
-        ScalarExpressionConcept<vector_scalar_unary<vector<double>, vector_norm_inf<double> > >::constraints ();
+        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_sum<T> > >::constraints ();
+        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_norm_1<T> > >::constraints ();
+        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_norm_2<T> > >::constraints ();
+        ScalarExpressionConcept<vector_scalar_unary<vector<T>, vector_norm_inf<T> > >::constraints ();
 
-        ScalarExpressionConcept<vector_scalar_binary<vector<double>, vector<double>, vector_inner_prod<double, double, double> > >::constraints ();
+        ScalarExpressionConcept<vector_scalar_binary<vector<T>, vector<T>, vector_inner_prod<T, T, T> > >::constraints ();
 #endif
 
         // Matrix Expressions
-#if defined (INTERNAL) || defined (INTERNAL_MATRIX_EXPRESSION)
-        MatrixExpressionConcept<matrix_reference<matrix<double> > >::constraints ();
-        MutableMatrixExpressionConcept<matrix_reference<matrix<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<double> >::const_iterator1,
-                                             matrix_reference<matrix<double> >::const_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<double> >::iterator1,
-                                                    matrix_reference<matrix<double> >::iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<double> >::const_reverse_iterator1,
-                                             matrix_reference<matrix<double> >::const_reverse_iterator2>::constraints ();
-        MutableIndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<double> >::reverse_iterator1,
-                                                    matrix_reference<matrix<double> >::reverse_iterator2>::constraints ();
+#if defined (INTERNAL_EXPRESSION) || defined (INTERNAL_MATRIX_EXPRESSION)
+        MatrixExpressionConcept<matrix_reference<matrix<T> > >::constraints ();
+        MutableMatrixExpressionConcept<matrix_reference<matrix<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::const_iterator1,
+                                             matrix_reference<matrix<T> >::const_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::iterator1,
+                                                    matrix_reference<matrix<T> >::iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::const_reverse_iterator1,
+                                             matrix_reference<matrix<T> >::const_reverse_iterator2>::constraints ();
+        MutableIndexedRandomAccess2DIteratorConcept<matrix_reference<matrix<T> >::reverse_iterator1,
+                                                    matrix_reference<matrix<T> >::reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<vector_matrix_binary<vector<double>, vector<double>, scalar_multiplies<double, double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<vector_matrix_binary<vector<double>, vector<double>, scalar_multiplies<double, double> >::const_iterator1,
-                                             vector_matrix_binary<vector<double>, vector<double>, scalar_multiplies<double, double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<vector_matrix_binary<vector<double>, vector<double>, scalar_multiplies<double, double> >::const_reverse_iterator1,
-                                             vector_matrix_binary<vector<double>, vector<double>, scalar_multiplies<double, double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_iterator1,
+                                             vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_reverse_iterator1,
+                                             vector_matrix_binary<vector<T>, vector<T>, scalar_multiplies<T, T> >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_unary1<matrix<double>, scalar_identity<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_unary1<matrix<double>, scalar_identity<double> >::const_iterator1,
-                                             matrix_unary1<matrix<double>, scalar_identity<double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_unary1<matrix<double>, scalar_identity<double> >::const_reverse_iterator1,
-                                             matrix_unary1<matrix<double>, scalar_identity<double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_unary1<matrix<T>, scalar_identity<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_unary1<matrix<T>, scalar_identity<T> >::const_iterator1,
+                                             matrix_unary1<matrix<T>, scalar_identity<T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_unary1<matrix<T>, scalar_identity<T> >::const_reverse_iterator1,
+                                             matrix_unary1<matrix<T>, scalar_identity<T> >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_unary2<matrix<double>, scalar_identity<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_unary2<matrix<double>, scalar_identity<double> >::const_iterator1,
-                                             matrix_unary2<matrix<double>, scalar_identity<double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_unary2<matrix<double>, scalar_identity<double> >::const_reverse_iterator1,
-                                             matrix_unary2<matrix<double>, scalar_identity<double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_unary2<matrix<T>, scalar_identity<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_unary2<matrix<T>, scalar_identity<T> >::const_iterator1,
+                                             matrix_unary2<matrix<T>, scalar_identity<T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_unary2<matrix<T>, scalar_identity<T> >::const_reverse_iterator1,
+                                             matrix_unary2<matrix<T>, scalar_identity<T> >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_binary<matrix<double>, matrix<double>, scalar_plus<double, double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary<matrix<double>, matrix<double>, scalar_plus<double, double> >::const_iterator1,
-                                             matrix_binary<matrix<double>, matrix<double>, scalar_plus<double, double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary<matrix<double>, matrix<double>, scalar_plus<double, double> >::const_reverse_iterator1,
-                                             matrix_binary<matrix<double>, matrix<double>, scalar_plus<double, double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_iterator1,
+                                             matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_reverse_iterator1,
+                                             matrix_binary<matrix<T>, matrix<T>, scalar_plus<T, T> >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_binary_scalar1<double, matrix<double>, scalar_multiplies<double, double>, scalar_reference<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<double, matrix<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_iterator1,
-                                             matrix_binary_scalar1<double, matrix<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<double, matrix<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_reverse_iterator1,
-                                             matrix_binary_scalar1<double, matrix<double>, scalar_multiplies<double, double>, scalar_reference<double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T>, scalar_reference<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_iterator1,
+                                             matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_reverse_iterator1,
+                                             matrix_binary_scalar1<T, matrix<T>, scalar_multiplies<T, T>, scalar_reference<T> >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_binary_scalar2<matrix<double>, double, scalar_multiplies<double, double>, scalar_reference<double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<double>, double, scalar_multiplies<double, double>, scalar_reference<double> >::const_iterator1,
-                                             matrix_binary_scalar2<matrix<double>, double, scalar_multiplies<double, double>, scalar_reference<double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<double>, double, scalar_multiplies<double, double>, scalar_reference<double> >::const_reverse_iterator1,
-                                             matrix_binary_scalar2<matrix<double>, double, scalar_multiplies<double, double>, scalar_reference<double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T>, scalar_reference<T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T>, scalar_reference<T> >::const_iterator1,
+                                             matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T>, scalar_reference<T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T>, scalar_reference<T> >::const_reverse_iterator1,
+                                             matrix_binary_scalar2<matrix<T>, T, scalar_multiplies<T, T>, scalar_reference<T> >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_binary_scalar1<scalar_value<double>, matrix<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<scalar_value<double>, matrix<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_iterator1,
-                                             matrix_binary_scalar1<scalar_value<double>, matrix<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<scalar_value<double>, matrix<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_reverse_iterator1,
-                                             matrix_binary_scalar1<scalar_value<double>, matrix<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_iterator1,
+                                             matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_reverse_iterator1,
+                                             matrix_binary_scalar1<scalar_value<T>, matrix<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_reverse_iterator2>::constraints ();
 
-        MatrixExpressionConcept<matrix_binary_scalar2<matrix<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_iterator1,
-                                             matrix_binary_scalar2<matrix<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_reverse_iterator1,
-                                             matrix_binary_scalar2<matrix<double>, scalar_value<double>, scalar_multiplies<double, double>, scalar_reference<scalar_value<double> > >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_iterator1,
+                                             matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_reverse_iterator1,
+                                             matrix_binary_scalar2<matrix<T>, scalar_value<T>, scalar_multiplies<T, T>, scalar_reference<scalar_value<T> > >::const_reverse_iterator2>::constraints ();
 
-        VectorExpressionConcept<matrix_vector_binary1<matrix<double>, vector<double>, matrix_vector_prod1<double, double, double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary1<matrix<double>, vector<double>, matrix_vector_prod1<double, double, double> >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary1<matrix<double>, vector<double>, matrix_vector_prod1<double, double, double> >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<matrix_vector_binary1<matrix<T>, vector<T>, matrix_vector_prod1<T, T, T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary1<matrix<T>, vector<T>, matrix_vector_prod1<T, T, T> >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary1<matrix<T>, vector<T>, matrix_vector_prod1<T, T, T> >::const_reverse_iterator>::constraints ();
 
-        VectorExpressionConcept<matrix_vector_binary2<vector<double>, matrix<double>, matrix_vector_prod2<double, double, double> > >::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary2<vector<double>, matrix<double>, matrix_vector_prod2<double, double, double> >::const_iterator>::constraints ();
-        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary2<vector<double>, matrix<double>, matrix_vector_prod2<double, double, double> >::const_reverse_iterator>::constraints ();
+        VectorExpressionConcept<matrix_vector_binary2<vector<T>, matrix<T>, matrix_vector_prod2<T, T, T> > >::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary2<vector<T>, matrix<T>, matrix_vector_prod2<T, T, T> >::const_iterator>::constraints ();
+        IndexedRandomAccess1DIteratorConcept<matrix_vector_binary2<vector<T>, matrix<T>, matrix_vector_prod2<T, T, T> >::const_reverse_iterator>::constraints ();
 
-        MatrixExpressionConcept<matrix_matrix_binary<matrix<double>, matrix<double>, matrix_matrix_prod<double, double, double> > >::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_matrix_binary<matrix<double>, matrix<double>, matrix_matrix_prod<double, double, double> >::const_iterator1,
-                                             matrix_matrix_binary<matrix<double>, matrix<double>, matrix_matrix_prod<double, double, double> >::const_iterator2>::constraints ();
-        IndexedRandomAccess2DIteratorConcept<matrix_matrix_binary<matrix<double>, matrix<double>, matrix_matrix_prod<double, double, double> >::const_reverse_iterator1,
-                                             matrix_matrix_binary<matrix<double>, matrix<double>, matrix_matrix_prod<double, double, double> >::const_reverse_iterator2>::constraints ();
+        MatrixExpressionConcept<matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> > >::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_iterator1,
+                                             matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_iterator2>::constraints ();
+        IndexedRandomAccess2DIteratorConcept<matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_reverse_iterator1,
+                                             matrix_matrix_binary<matrix<T>, matrix<T>, matrix_matrix_prod<T, T, T> >::const_reverse_iterator2>::constraints ();
 
-        ScalarExpressionConcept<matrix_scalar_unary<matrix<double>, matrix_norm_1<double> > >::constraints ();
-        ScalarExpressionConcept<matrix_scalar_unary<matrix<double>, matrix_norm_frobenius<double> > >::constraints ();
-        ScalarExpressionConcept<matrix_scalar_unary<matrix<double>, matrix_norm_inf<double> > >::constraints ();
+        ScalarExpressionConcept<matrix_scalar_unary<matrix<T>, matrix_norm_1<T> > >::constraints ();
+        ScalarExpressionConcept<matrix_scalar_unary<matrix<T>, matrix_norm_frobenius<T> > >::constraints ();
+        ScalarExpressionConcept<matrix_scalar_unary<matrix<T>, matrix_norm_inf<T> > >::constraints ();
 #endif
 
 #ifdef EXTERNAL