From dc9e3f7bdeee091242f583cc015902ee5ec354ec Mon Sep 17 00:00:00 2001
From: Michael Stevens <mail@michael-stevens.de>
Date: Sat, 4 Sep 2004 14:48:53 +0000
Subject: [PATCH] OLD_INIT syntax for nil_ static members

[SVN r24903]
---
 include/boost/numeric/ublas/banded.hpp        |   6 +-
 include/boost/numeric/ublas/hermitian.hpp     |   8 +
 .../boost/numeric/ublas/matrix_expression.hpp |  13 +-
 include/boost/numeric/ublas/matrix_proxy.hpp  | 202 ++++++++++--------
 include/boost/numeric/ublas/symmetric.hpp     |   7 +-
 include/boost/numeric/ublas/triangular.hpp    |   6 +-
 .../boost/numeric/ublas/vector_expression.hpp |  11 +-
 include/boost/numeric/ublas/vector_proxy.hpp  |  82 ++++---
 8 files changed, 208 insertions(+), 127 deletions(-)

diff --git a/include/boost/numeric/ublas/banded.hpp b/include/boost/numeric/ublas/banded.hpp
index 1892364c..f98a6e7e 100644
--- a/include/boost/numeric/ublas/banded.hpp
+++ b/include/boost/numeric/ublas/banded.hpp
@@ -2036,7 +2036,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename banded_adaptor<M>::matrix_type banded_adaptor<M>::nil_;
+    typename banded_adaptor<M>::matrix_type banded_adaptor<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME banded_adaptor<M>::matrix_type ()
+#endif
+    ;
     template<class M>
     typename banded_adaptor<M>::const_value_type banded_adaptor<M>::zero_
 #ifdef BOOST_UBLAS_STATIC_OLD_INIT
diff --git a/include/boost/numeric/ublas/hermitian.hpp b/include/boost/numeric/ublas/hermitian.hpp
index 02399b9f..6d8fabb1 100644
--- a/include/boost/numeric/ublas/hermitian.hpp
+++ b/include/boost/numeric/ublas/hermitian.hpp
@@ -2553,8 +2553,16 @@ namespace boost { namespace numeric { namespace ublas {
 
     template<class M, class F>
     typename hermitian_adaptor<M, F>::matrix_type hermitian_adaptor<M, F>::nil_;
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME hermitian_adaptor<M, F>::matrix_type()
+#endif
+    ;
     template<class M, class F>
     typename hermitian_adaptor<M, F>::value_type hermitian_adaptor<M, F>::conj_;
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME hermitian_adaptor<M, F>::value_type()
+#endif
+    ;
 
 }}}
 
diff --git a/include/boost/numeric/ublas/matrix_expression.hpp b/include/boost/numeric/ublas/matrix_expression.hpp
index 0240dafb..b8b26ca8 100644
--- a/include/boost/numeric/ublas/matrix_expression.hpp
+++ b/include/boost/numeric/ublas/matrix_expression.hpp
@@ -335,7 +335,12 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class E>
-    const typename matrix_const_reference<E>::expression_type matrix_const_reference<E>::nil_;
+    const typename matrix_const_reference<E>::expression_type matrix_const_reference<E>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_const_reference<E>::expression_type()
+#endif
+    ;
+
 #endif
 
     template<class E>
@@ -620,7 +625,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class E>
-    typename matrix_reference<E>::expression_type matrix_reference<E>::nil_;
+    typename matrix_reference<E>::expression_type matrix_reference<E>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_reference<E>::expression_type()
+#endif
+    ;
 
     template<class E1, class E2, class F>
     class vector_matrix_binary:
diff --git a/include/boost/numeric/ublas/matrix_proxy.hpp b/include/boost/numeric/ublas/matrix_proxy.hpp
index 4670897c..fa0d8f44 100644
--- a/include/boost/numeric/ublas/matrix_proxy.hpp
+++ b/include/boost/numeric/ublas/matrix_proxy.hpp
@@ -133,62 +133,62 @@ namespace boost { namespace numeric { namespace ublas {
         matrix_row &operator = (const matrix_row &mr) {
             // FIXME: the rows could be differently sized.
             // std::copy (mr.begin (), mr.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mr));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mr));
             return *this;
         }
         BOOST_UBLAS_INLINE
         matrix_row &assign_temporary (matrix_row &mr) {
             // FIXME: this is suboptimal.
             // return *this = mr;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mr);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mr);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_row &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_row &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_row &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_row &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_row &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_row &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_row &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_row &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -513,7 +513,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename matrix_row<M>::matrix_type matrix_row<M>::nil_;
+    typename matrix_row<M>::matrix_type matrix_row<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_row<M>::matrix_type()
+#endif
+    ;
 
     // Projections
     template<class M>
@@ -642,62 +646,62 @@ namespace boost { namespace numeric { namespace ublas {
         matrix_column &operator = (const matrix_column &mc) {
             // FIXME: the columns could be differently sized.
             // std::copy (mc.begin (), mc.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mc));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mc));
             return *this;
         }
         BOOST_UBLAS_INLINE
         matrix_column &assign_temporary (matrix_column &mc) {
             // FIXME: this is suboptimal.
             // return *this = mc;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mc);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mc);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_column &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_column &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_column &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_column &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_column &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_column &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_column &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_column &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -1024,7 +1028,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename matrix_column<M>::matrix_type matrix_column<M>::nil_;
+    typename matrix_column<M>::matrix_type matrix_column<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_column<M>::matrix_type()
+#endif
+    ;
 
     // Projections
     template<class M>
@@ -1161,62 +1169,62 @@ namespace boost { namespace numeric { namespace ublas {
         matrix_vector_range &operator = (const matrix_vector_range &mvr) {
             // FIXME: the ranges could be differently sized.
             // std::copy (mvr.begin (), mvr.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mvr));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mvr));
             return *this;
         }
         BOOST_UBLAS_INLINE
         matrix_vector_range &assign_temporary (matrix_vector_range &mvr) {
             // FIXME: this is suboptimal.
             // return *this = mvr;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mvr);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mvr);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_range &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_range &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_range &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_range &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_range &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_range &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_vector_range &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_vector_range &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -1540,7 +1548,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename matrix_vector_range<M>::matrix_type matrix_vector_range<M>::nil_;
+    typename matrix_vector_range<M>::matrix_type matrix_vector_range<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_vector_range<M>::matrix_type()
+#endif
+    ;
 
     // Matrix based vector slice class
     template<class M>
@@ -1665,62 +1677,62 @@ namespace boost { namespace numeric { namespace ublas {
         matrix_vector_slice &operator = (const matrix_vector_slice &mvs) {
             // FIXME: the slices could be differently sized.
             // std::copy (mvs.begin (), mvs.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mvs));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mvs));
             return *this;
         }
         BOOST_UBLAS_INLINE
         matrix_vector_slice &assign_temporary (matrix_vector_slice &mvs) {
             // FIXME: this is suboptimal.
             // return *this = mvs;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mvs);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mvs);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_vector_slice &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -2046,7 +2058,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename matrix_vector_slice<M>::matrix_type matrix_vector_slice<M>::nil_;
+    typename matrix_vector_slice<M>::matrix_type matrix_vector_slice<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_vector_slice<M>::matrix_type()
+#endif
+    ;
 
     // Matrix based vector indirection class
     template<class M, class IA>
@@ -2172,62 +2188,62 @@ namespace boost { namespace numeric { namespace ublas {
         matrix_vector_indirect &operator = (const matrix_vector_indirect &mvi) {
             // FIXME: the indirects could be differently sized.
             // std::copy (mvi.begin (), mvi.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mvi));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mvi));
             return *this;
         }
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &assign_temporary (matrix_vector_indirect &mvi) {
             // FIXME: this is suboptimal.
             // return *this = mvi;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mvi);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mvi);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_vector_indirect &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -2553,7 +2569,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M, class IA>
-    typename matrix_vector_indirect<M, IA>::matrix_type matrix_vector_indirect<M, IA>::nil_;
+    typename matrix_vector_indirect<M, IA>::matrix_type matrix_vector_indirect<M, IA>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_indirect<M, IA>::matrix_type()
+#endif
+    ;
 
     // Matrix based range class
     template<class M>
@@ -2673,7 +2693,7 @@ namespace boost { namespace numeric { namespace ublas {
         // Assignment
         BOOST_UBLAS_INLINE
         matrix_range &operator = (const matrix_range &mr) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, mr);
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, mr);
             return *this;
         }
         BOOST_UBLAS_INLINE
@@ -2683,49 +2703,49 @@ namespace boost { namespace numeric { namespace ublas {
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_range &operator = (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_range &assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_range& operator += (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_range &plus_assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_plus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_range& operator -= (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_range &minus_assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_minus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_range& operator *= (const AT &at) {
-            matrix_assign_scalar (scalar_multiplies_assign<typename iterator1::reference, AT> (), *this, at);
+            matrix_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_range& operator /= (const AT &at) {
-            matrix_assign_scalar (scalar_divides_assign<typename iterator1::reference, AT> (), *this, at);
+            matrix_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -3448,7 +3468,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename matrix_range<M>::matrix_type matrix_range<M>::nil_;
+    typename matrix_range<M>::matrix_type matrix_range<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_range<M>::matrix_type()
+#endif
+    ;
 
     // Projections
     template<class M>
@@ -3609,7 +3633,7 @@ namespace boost { namespace numeric { namespace ublas {
         // Assignment
         BOOST_UBLAS_INLINE
         matrix_slice &operator = (const matrix_slice &ms) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, ms);
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, ms);
             return *this;
         }
         BOOST_UBLAS_INLINE
@@ -3619,49 +3643,49 @@ namespace boost { namespace numeric { namespace ublas {
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_slice &operator = (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_slice &assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_slice& operator += (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_slice &plus_assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_plus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_slice& operator -= (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_slice &minus_assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_minus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_slice& operator *= (const AT &at) {
-            matrix_assign_scalar (scalar_multiplies_assign<typename iterator1::reference, AT> (), *this, at);
+            matrix_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_slice& operator /= (const AT &at) {
-            matrix_assign_scalar (scalar_divides_assign<typename iterator1::reference, AT> (), *this, at);
+            matrix_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -4383,7 +4407,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M>
-    typename matrix_slice<M>::matrix_type matrix_slice<M>::nil_;
+    typename matrix_slice<M>::matrix_type matrix_slice<M>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_slice<M>::matrix_type()
+#endif
+    ;
 
     // Projections
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -4554,7 +4582,7 @@ namespace boost { namespace numeric { namespace ublas {
         // Assignment
         BOOST_UBLAS_INLINE
         matrix_indirect &operator = (const matrix_indirect &mi) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, mi);
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, mi);
             return *this;
         }
         BOOST_UBLAS_INLINE
@@ -4564,49 +4592,49 @@ namespace boost { namespace numeric { namespace ublas {
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_indirect &operator = (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_indirect &assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_indirect& operator += (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_indirect &plus_assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_plus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_indirect& operator -= (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
+            matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         matrix_indirect &minus_assign (const matrix_expression<AE> &ae) {
-            matrix_assign (scalar_minus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            matrix_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_indirect& operator *= (const AT &at) {
-            matrix_assign_scalar (scalar_multiplies_assign<typename iterator1::reference, AT> (), *this, at);
+            matrix_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         matrix_indirect& operator /= (const AT &at) {
-            matrix_assign_scalar (scalar_divides_assign<typename iterator1::reference, AT> (), *this, at);
+            matrix_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -5327,7 +5355,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M, class IA>
-    typename matrix_indirect<M, IA>::matrix_type matrix_indirect<M, IA>::nil_;
+    typename matrix_indirect<M, IA>::matrix_type matrix_indirect<M, IA>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME matrix_indirect<M, IA>::matrix_type()
+#endif
+    ;
 
     // Projections
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
diff --git a/include/boost/numeric/ublas/symmetric.hpp b/include/boost/numeric/ublas/symmetric.hpp
index 8493ea5e..a4433b6c 100644
--- a/include/boost/numeric/ublas/symmetric.hpp
+++ b/include/boost/numeric/ublas/symmetric.hpp
@@ -2183,7 +2183,12 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M, class F>
-    typename symmetric_adaptor<M, F>::matrix_type symmetric_adaptor<M, F>::nil_;
+    typename symmetric_adaptor<M, F>::matrix_type symmetric_adaptor<M, F>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME symmetric_adaptor<M, F>::matrix_type ():
+#endif
+    ;
+
 
 }}}
 
diff --git a/include/boost/numeric/ublas/triangular.hpp b/include/boost/numeric/ublas/triangular.hpp
index bd358ac2..ff867c8c 100644
--- a/include/boost/numeric/ublas/triangular.hpp
+++ b/include/boost/numeric/ublas/triangular.hpp
@@ -1849,7 +1849,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class M, class F>
-    typename triangular_adaptor<M, F>::matrix_type triangular_adaptor<M, F>::nil_;
+    typename triangular_adaptor<M, F>::matrix_type triangular_adaptor<M, F>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME triangular_adaptor<M, F>::matrix_type ()
+#endif
+    ;
     template<class M, class F>
     const typename triangular_adaptor<M, F>::value_type triangular_adaptor<M, F>::zero_
 #ifdef BOOST_UBLAS_STATIC_OLD_INIT
diff --git a/include/boost/numeric/ublas/vector_expression.hpp b/include/boost/numeric/ublas/vector_expression.hpp
index 444eef8b..34aefe60 100644
--- a/include/boost/numeric/ublas/vector_expression.hpp
+++ b/include/boost/numeric/ublas/vector_expression.hpp
@@ -103,7 +103,10 @@ namespace boost { namespace numeric { namespace ublas {
 
     template<class T>
     const typename scalar_const_reference<T>::value_type scalar_const_reference<T>::nil_
-        = BOOST_UBLAS_TYPENAME scalar_const_reference<T>::value_type ();
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME scalar_const_reference<T>::value_type ()
+#endif
+    ;
 
 
 
@@ -424,7 +427,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class E>
-    typename vector_reference<E>::expression_type vector_reference<E>::nil_;
+    typename vector_reference<E>::expression_type vector_reference<E>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME vector_reference<E>::expression_type ();
+#endif
+    ;
 
     template<class E, class F>
     class vector_unary:
diff --git a/include/boost/numeric/ublas/vector_proxy.hpp b/include/boost/numeric/ublas/vector_proxy.hpp
index ea44d2f9..f24b07a1 100644
--- a/include/boost/numeric/ublas/vector_proxy.hpp
+++ b/include/boost/numeric/ublas/vector_proxy.hpp
@@ -139,62 +139,62 @@ namespace boost { namespace numeric { namespace ublas {
         vector_range &operator = (const vector_range &vr) {
             // FIXME: the ranges could be differently sized.
             // std::copy (vr.begin (), vr.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vr));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (vr));
             return *this;
         }
         BOOST_UBLAS_INLINE
         vector_range &assign_temporary (vector_range &vr) {
             // FIXME: this is suboptimal.
             // return *this = vr;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vr);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vr);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_range &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_range &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_range &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_range &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_range &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_range &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         vector_range &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         vector_range &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -519,7 +519,11 @@ namespace boost { namespace numeric { namespace ublas {
     };
 
     template<class V>
-    typename vector_range<V>::vector_type vector_range<V>::nil_;
+    typename vector_range<V>::vector_type vector_range<V>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME vector_range<V>::vector_type()
+#endif
+    ;
 
     // Projections
     template<class V>
@@ -673,69 +677,69 @@ namespace boost { namespace numeric { namespace ublas {
         vector_slice &operator = (const vector_slice &vs) {
             // FIXME: the slices could be differently sized.
             // std::copy (vs.begin (), vs.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vs));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (vs));
             return *this;
         }
         BOOST_UBLAS_INLINE
         vector_slice &assign_temporary (vector_slice &vs) {
             // FIXME: this is suboptimal.
             // return *this = vs;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vs);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vs);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_slice &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_slice &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_slice &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_slice &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_slice &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_slice &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         vector_slice &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         vector_slice &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
         // Closure comparison
         BOOST_UBLAS_INLINE
         bool same_closure (const vector_slice &vr) const {
-return true;
+            return (*this).data_.same_closure (vr.data_);
         }
 
         // Comparison
@@ -1046,8 +1050,12 @@ return true;
     };
 
     template<class V>
-    typename vector_slice<V>::vector_type vector_slice<V>::nil_;
-
+    typename vector_slice<V>::vector_type vector_slice<V>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME vector_slice<V>::vector_type()
+#endif
+    ;
+    
     // Projections
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
     template<class V>
@@ -1214,62 +1222,62 @@ return true;
         vector_indirect &operator = (const vector_indirect &vi) {
             // FIXME: the indirect_arrays could be differently sized.
             // std::copy (vi.begin (), vi.end (), begin ());
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vi));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (vi));
             return *this;
         }
         BOOST_UBLAS_INLINE
         vector_indirect &assign_temporary (vector_indirect &vi) {
             // FIXME: this is suboptimal.
             // return *this = vi;
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vi);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vi);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_indirect &operator = (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_indirect &assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_indirect &operator += (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this + ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this + ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_indirect &plus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_indirect &operator -= (const vector_expression<AE> &ae) {
-            vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this - ae));
+            vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this - ae));
             return *this;
         }
         template<class AE>
         BOOST_UBLAS_INLINE
         vector_indirect &minus_assign (const vector_expression<AE> &ae) {
-            vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
+            vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         vector_indirect &operator *= (const AT &at) {
-            vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
         template<class AT>
         BOOST_UBLAS_INLINE
         vector_indirect &operator /= (const AT &at) {
-            vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
+            vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
             return *this;
         }
 
@@ -1588,7 +1596,11 @@ return true;
     };
 
     template<class V, class IA>
-    typename vector_indirect<V, IA>::vector_type vector_indirect<V, IA>::nil_;
+    typename vector_indirect<V, IA>::vector_type vector_indirect<V, IA>::nil_
+#ifdef BOOST_UBLAS_STATIC_OLD_INIT
+        = BOOST_UBLAS_TYPENAME vector_indirect<V, IA>::vector_type()
+#endif
+    ;
 
     // Projections
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING