[Boost-commit] svn:boost r79894 - in sandbox/big_number: boost/multiprecision libs/multiprecision/performance libs/multiprecision/test libs/multiprecision/test/include_test libs/multiprecision/test/ublas_interop libs/multiprecision/test/ublas_interop/common

Subject: [Boost-commit] svn:boost r79894 - in sandbox/big_number: boost/multiprecision libs/multiprecision/performance libs/multiprecision/test libs/multiprecision/test/include_test libs/multiprecision/test/ublas_interop libs/multiprecision/test/ublas_interop/common
From: john_at_[hidden]
Date: 2012-08-07 04:10:16

Author: johnmaddock
Date: 2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
New Revision: 79894
URL: http://svn.boost.org/trac/boost/changeset/79894

Log:
Add uBlas interoperability tests.
Add file include tests.
Added:
   sandbox/big_number/libs/multiprecision/test/include_test/
   sandbox/big_number/libs/multiprecision/test/include_test/cpp_dec_float_include_test.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/include_test/gmp_include_test.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/include_test/mpfr_include_test.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/include_test/tommath_include_test.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/
   sandbox/big_number/libs/multiprecision/test/ublas_interop/common/
   sandbox/big_number/libs/multiprecision/test/ublas_interop/common/init.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/common/testhelper.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test11.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test12.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test13.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test21.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test22.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test23.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test31.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test32.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test33.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test42.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test43.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test52.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test53.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test6.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test6.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test62.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test63.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test71.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test72.cpp   (contents, props changed)
   sandbox/big_number/libs/multiprecision/test/ublas_interop/test73.cpp   (contents, props changed)
Text files modified: 
   sandbox/big_number/boost/multiprecision/mp_number.hpp                 |   148 ++++----------------------------------- 
   sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp |     2                                         
   sandbox/big_number/libs/multiprecision/test/Jamfile.v2                |    22 +++++                                   
   3 files changed, 39 insertions(+), 133 deletions(-)

Modified: sandbox/big_number/boost/multiprecision/mp_number.hpp
==============================================================================
--- sandbox/big_number/boost/multiprecision/mp_number.hpp	(original)
+++ sandbox/big_number/boost/multiprecision/mp_number.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -1541,138 +1541,6 @@
    Backend m_backend;
 };
 
-/*
-namespace detail
-{
-
-template <class Backend, bool ExpressionTemplates>
-BOOST_FORCEINLINE int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
-   return a.compare(b);
-}
-
-template <class Backend, bool ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
-BOOST_FORCEINLINE int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const mp_exp<tag, A1, A2, A3, A4>& b)
-{
-   return a.compare(mp_number<Backend, ExpressionTemplates>(b));
-}
-
-template <class tag, class A1, class A2, class A3, class A4, class Backend, bool ExpressionTemplates>
-inline int mp_number_compare(const mp_exp<tag, A1, A2, A3, A4>& a, const mp_number<Backend, ExpressionTemplates>& b)
-{
-   return -b.compare(mp_number<Backend, ExpressionTemplates>(a));
-}
-
-template <class Backend, bool ExpressionTemplates, class Val>
-inline int mp_number_compare(const mp_number<Backend, ExpressionTemplates>& a, const Val b)
-{
-   return a.compare(b);
-}
-
-template <class Val, class Backend, bool ExpressionTemplates>
-inline int mp_number_compare(const Val a, const mp_number<Backend, ExpressionTemplates>& b)
-{
-   return -b.compare(a);
-}
-
-template <class tag, class A1, class A2, class A3, class A4, class tag2, class A1b, class A2b, class A3b>
-inline int mp_number_compare(const mp_exp<tag, A1, A2, A3, A4>& a, const mp_exp<tag2, A1b, A2b, A3b>& b)
-{
-   typedef typename mp_exp<tag, A1, A2, A3, A4>::result_type real1;
-   typedef typename mp_exp<tag2, A1b, A2b, A3b>::result_type real2;
-   return real1(a).compare(real2(b));
-}
-
-template <class tag, class A1, class A2, class A3, class A4, class Val>
-inline typename enable_if<is_arithmetic<Val>, int>::type mp_number_compare(const mp_exp<tag, A1, A2, A3, A4>& a, const Val b)
-{
-   typedef typename mp_exp<tag, A1, A2, A3, A4>::result_type real;
-   real t(a);
-   return t.compare(b);
-}
-
-template <class Val, class tag, class A1, class A2, class A3, class A4>
-inline typename enable_if<is_arithmetic<Val>, int>::type mp_number_compare(const Val a, const mp_exp<tag, A1, A2, A3, A4>& b)
-{
-   typedef typename mp_exp<tag, A1, A2, A3, A4>::result_type real;
-   return -real(b).compare(a);
-}
-
-template <class Exp1, class Exp2>
-struct is_valid_comparison_imp
-{
-   typedef typename mpl::or_<
-      is_mp_number<Exp1>,
-      is_mp_number_exp<Exp1>
-   >::type is1;
-   typedef typename mpl::or_<
-      is_mp_number<Exp2>,
-      is_mp_number_exp<Exp2>
-   >::type is2;
-   typedef typename mpl::or_<
-      mpl::and_<
-         is1,
-         mpl::or_<
-            is2,
-            is_arithmetic<Exp2>
-         >
-      >,
-      mpl::and_<
-         is2,
-         mpl::or_<
-            is1,
-            is_arithmetic<Exp1>
-         >
-      >
-   >::type type;
-};
-
-template <class Exp1, class Exp2>
-struct is_valid_comparison : public boost::multiprecision::detail::is_valid_comparison_imp<Exp1, Exp2>::type {};
-
-}
-
-template <class Exp1, class Exp2>
-inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type 
-   operator == (const Exp1& a, const Exp2& b)
-{
-   return 0 == detail::mp_number_compare(a, b);
-}
-template <class Exp1, class Exp2>
-inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type 
-   operator != (const Exp1& a, const Exp2& b)
-{
-   return 0 != detail::mp_number_compare(a, b);
-}
-
-template <class Exp1, class Exp2>
-inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type 
-   operator <= (const Exp1& a, const Exp2& b)
-{
-   return 0 >= detail::mp_number_compare(a, b);
-}
-
-template <class Exp1, class Exp2>
-inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type 
-   operator < (const Exp1& a, const Exp2& b)
-{
-   return 0 > detail::mp_number_compare(a, b);
-}
-
-template <class Exp1, class Exp2>
-inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type 
-   operator >= (const Exp1& a, const Exp2& b)
-{
-   return 0 <= detail::mp_number_compare(a, b);
-}
-
-template <class Exp1, class Exp2>
-inline typename boost::enable_if<detail::is_valid_comparison<Exp1, Exp2>, bool>::type 
-   operator > (const Exp1& a, const Exp2& b)
-{
-   return 0 < detail::mp_number_compare(a, b);
-}
-*/
 template <class Backend, bool ExpressionTemplates>
 inline std::ostream& operator << (std::ostream& os, const mp_number<Backend, ExpressionTemplates>& r)
 {
@@ -1793,6 +1661,22 @@
    return a.denominator();
 }
 
+namespace numeric { namespace ublas {
+//
+// uBlas interoperability:
+//
+template<class V>
+class sparse_vector_element;
+
+template <class V, class Backend, bool ExpressionTemplates>
+inline bool operator == (const sparse_vector_element<V>& a, const ::boost::multiprecision::mp_number<Backend, ExpressionTemplates>& b)
+{
+typedef typename sparse_vector_element<V>::const_reference ref_type;
+   return static_cast<ref_type>(a) == b;
+}
+
+}} // namespaces
+
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

Modified: sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp	(original)
+++ sandbox/big_number/libs/multiprecision/performance/sf_performance.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -225,7 +225,7 @@
 int main()
 {
    using namespace boost::multiprecision;
-#if defined(TEST_MPFR) || defined(TEST_MPFR_CLASS) || defined(TEST_MPREAL)
+#if defined(TEST_MPFR) || defined(TEST_MPFR_CLASS) || defined(TEST_MPREAL) || defined(TEST_MPF)
    mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
    mp_set_memory_functions(&alloc_func, &realloc_func, &free_func);
 #endif

Modified: sandbox/big_number/libs/multiprecision/test/Jamfile.v2
==============================================================================
--- sandbox/big_number/libs/multiprecision/test/Jamfile.v2	(original)
+++ sandbox/big_number/libs/multiprecision/test/Jamfile.v2	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -731,6 +731,27 @@
          [ check-target-builds ../config//has_tommath : : <build>no ] ;
 run ../example/floating_point_examples.cpp : : : <toolset>gcc:<cxxflags>-std=c++0x ;
 
+compile include_test/mpfr_include_test.cpp
+              : # requirements
+               [ check-target-builds ../config//has_mpfr : : <build>no ] ;
+compile include_test/gmp_include_test.cpp
+              : # requirements
+               [ check-target-builds ../config//has_gmp : : <build>no ] ;
+compile include_test/tommath_include_test.cpp 
+              : # requirements
+               [ check-target-builds ../config//has_tommath : : <build>no ] ;
+compile include_test/cpp_int_include_test.cpp ;
+compile include_test/cpp_dec_float_include_test.cpp ;
+
+run ublas_interop/test1.cpp ublas_interop/test11.cpp ublas_interop/test12.cpp ublas_interop/test13.cpp ;
+run ublas_interop/test2.cpp ublas_interop/test21.cpp ublas_interop/test22.cpp ublas_interop/test23.cpp ;
+#run ublas_interop/test3.cpp ublas_interop/test31.cpp ublas_interop/test32.cpp ublas_interop/test33.cpp ;
+run ublas_interop/test4.cpp ublas_interop/test42.cpp ublas_interop/test43.cpp ;
+run ublas_interop/test5.cpp ublas_interop/test52.cpp ublas_interop/test53.cpp ;
+run ublas_interop/test6.cpp ublas_interop/test62.cpp ublas_interop/test63.cpp ;
+run ublas_interop/test7.cpp ublas_interop/test71.cpp ublas_interop/test72.cpp ublas_interop/test73.cpp ;
+
+
 if $(enable-specfun)
 {
 
@@ -771,6 +792,7 @@
    }
 }
 
+
 if ! $(disable-concepts)
 {
 

Added: sandbox/big_number/libs/multiprecision/test/include_test/cpp_dec_float_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/include_test/cpp_dec_float_include_test.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,12 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
+
+#include <boost/multiprecision/cpp_dec_float.hpp>
+
+using namespace boost::multiprecision;
+
+cpp_dec_float<50> a;
+
+

Added: sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/include_test/cpp_int_include_test.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,16 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
+
+#include <boost/multiprecision/cpp_int.hpp>
+
+using namespace boost::multiprecision;
+
+mp_number<cpp_int_backend<> > a;
+mp_number<cpp_int_backend<>, false> b;
+mp_number<cpp_int_backend<64, true, void>, false> c;
+mp_number<cpp_int_backend<128, false, void>, false> d;
+mp_number<cpp_int_backend<500, true, void>, false> e;
+
+

Added: sandbox/big_number/libs/multiprecision/test/include_test/gmp_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/include_test/gmp_include_test.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,14 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
+
+#include <boost/multiprecision/gmp.hpp>
+
+using namespace boost::multiprecision;
+
+mpf_float a;
+mpz_int b;
+mpq_rational c;
+
+

Added: sandbox/big_number/libs/multiprecision/test/include_test/mpfr_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/include_test/mpfr_include_test.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,12 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
+
+#include <boost/multiprecision/mpfr.hpp>
+
+using namespace boost::multiprecision;
+
+mpfr_float a;
+
+

Added: sandbox/big_number/libs/multiprecision/test/include_test/tommath_include_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/include_test/tommath_include_test.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,12 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
+
+#include <boost/multiprecision/tommath.hpp>
+
+using namespace boost::multiprecision;
+
+tom_int a;
+
+

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/common/init.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/common/init.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2004 Michael Stevens
+ * Use, modification and distribution are subject to the
+ * Boost Software License, Version 1.0. (See accompanying file
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+/*
+ * Default construct test when possible
+ */
+
+template <class E>
+struct default_construct
+{
+    static void test() {}
+}; 
+template <class VC>
+struct default_construct<boost::numeric::ublas::vector_container<VC> >
+{
+    static void test ()
+    {
+        VC default_constuct;
+        initialize_vector (default_constuct);
+        std::cout << "default construct = " << default_constuct << std::endl;
+    }
+};
+template <class MC>
+struct default_construct<boost::numeric::ublas::matrix_container<MC> >
+{
+    static void test ()
+    {
+        MC default_constuct;
+        initialize_vector (default_constuct);
+        std::cout << "default construct = " << default_constuct << std::endl;
+    }
+};
+
+/*
+ * Initialise test values in vector/matrix
+ */
+
+template<class V>
+void initialize_vector (V &v) {
+    typename V::size_type size = v.size ();
+    for (typename V::size_type i = 0; i < size; ++ i)
+        v [i] = typename V::value_type ( i + 1.f );
+}
+
+template<class M>
+void initialize_matrix_impl (M &m, ublas::packed_proxy_tag) {
+    typename M::size_type size1 = m.size1 ();
+#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
+    for (typename M::iterator1 i = m.begin1(); i != m.end1(); ++ i)
+        for (typename M::iterator2 j = i.begin(); j != i.end(); ++ j)
+            *j = typename M::value_type ( i.index1() * size1 + j.index2() + 1.f );
+#else
+    for (typename M::iterator1 i = m.begin1(); i != m.end1(); ++ i)
+        for (typename M::iterator2 j = ublas::begin (i, ublas::iterator1_tag ()); j != ublas::end (i, ublas::iterator1_tag ()); ++ j)
+            *j = typename M::value_type ( i.index1() * size1 + j.index2() + 1.f );
+#endif
+}
+
+template<class M>
+void initialize_matrix_impl (M &m, ublas::sparse_proxy_tag) {
+    typename M::size_type size1 = m.size1 ();
+    typename M::size_type size2 = m.size2 ();
+    for (typename M::size_type i = 0; i < size1; ++ i)
+        for (typename M::size_type j = 0; j < size2; ++ j)
+            m (i, j) = typename M::value_type (i * size1 + j + 1.f);
+}
+
+template<class M>
+void initialize_matrix (M &m) {
+    initialize_matrix_impl (m, typename M::storage_category());
+}
+
+template<class M>
+void initialize_matrix (M &m, ublas::lower_tag) {
+    typename M::size_type size1 = m.size1 ();
+    typename M::size_type size2 = m.size2 ();
+    for (typename M::size_type i = 0; i < size1; ++ i) {
+        typename M::size_type j = 0;
+        for (; j <= i; ++ j)
+            m (i, j) = i * size1 + j + 1.f;
+        for (; j < size2; ++ j)
+            m (i, j) = 0.f;
+    }
+}
+template<class M>
+void initialize_matrix (M &m, ublas::upper_tag) {
+    typename M::size_type size1 = m.size1 ();
+    typename M::size_type size2 = m.size2 ();
+    for (typename M::size_type i = 0; i < size1; ++ i) {
+        typename M::size_type j = 0;
+        for (; j < i; ++ j)
+            m (i, j) = 0.f;
+        for (; j < size2; ++ j)
+            m (i, j) = i * size1 + j + 1.f;
+    }
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/common/testhelper.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/common/testhelper.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,74 @@
+// Copyright 2008 Gunter Winkler <guwi17_at_[hidden]>
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef _HPP_TESTHELPER_
+#define _HPP_TESTHELPER_
+
+#include <utility>
+
+static unsigned _success_counter = 0;
+static unsigned _fail_counter    = 0;
+
+static inline
+void assertTrue(const char* message, bool condition) {
+#ifndef NOMESSAGES
+  std::cout << message;
+#endif
+  if ( condition ) {
+    ++ _success_counter;
+    std::cout << "1\n"; // success
+  } else {
+    ++ _fail_counter;
+    std::cout << "0\n"; // failed
+  }
+}
+
+template < class T >
+void assertEquals(const char* message, T expected, T actual) {
+#ifndef NOMESSAGES
+  std::cout << message;
+#endif
+  if ( expected == actual ) {
+    ++ _success_counter;
+    std::cout << "1\n"; // success
+  } else {
+    #ifndef NOMESSAGES
+      std::cout << " expected " << expected << " actual " << actual << " ";
+    #endif
+    ++ _fail_counter;
+    std::cout << "0\n"; // failed
+  }
+}
+
+static
+std::pair<unsigned, unsigned> getResults() {
+  return std::make_pair(_success_counter, _fail_counter);
+}
+
+template < class M1, class M2 >
+bool compare( const boost::numeric::ublas::matrix_expression<M1> & m1, 
+              const boost::numeric::ublas::matrix_expression<M2> & m2 ) {
+  size_t size1 = (std::min)(m1().size1(), m2().size1());
+  size_t size2 = (std::min)(m1().size2(), m2().size2());
+  for (size_t i=0; i < size1; ++i) {
+    for (size_t j=0; j < size2; ++j) {
+      if ( m1()(i,j) != m2()(i,j) ) return false;
+    }
+  }
+  return true;
+}
+
+template < class M1, class M2 >
+bool compare( const boost::numeric::ublas::vector_expression<M1> & m1, 
+              const boost::numeric::ublas::vector_expression<M2> & m2 ) {
+  size_t size = (std::min)(m1().size(), m2().size());
+  for (size_t i=0; i < size; ++i) {
+    if ( m1()(i) != m2()(i) ) return false;
+  }
+  return true;
+}
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,20 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test1.hpp"
+
+int main () {
+    test_vector ();
+    test_matrix_vector ();
+    test_matrix ();
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test1.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,45 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST1_H
+#define TEST1_H
+
+#include <iostream>
+
+#ifdef _MSC_VER
+#  pragma warning(disable:4800 4996)
+#endif
+
+#include <boost/multiprecision/cpp_dec_float.hpp>
+
+typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+//typedef double mp_test_type;
+
+#define USE_RANGE
+#define USE_SLICE
+
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/vector_proxy.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/matrix_proxy.hpp>
+#include <boost/numeric/ublas/io.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+void test_vector ();
+void test_matrix_vector ();
+void test_matrix ();
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test11.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test11.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,182 @@
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+
+#include "test1.hpp"
+
+// Test vector expression templates
+template<class V, int N>
+struct test_my_vector {
+    typedef typename V::value_type value_type;
+    typedef typename V::size_type size_type;
+    typedef typename ublas::type_traits<value_type>::real_type real_type;
+
+    template<class VP>
+    void test_container_with (VP &v1) const {
+        // Container type tests in addition to expression types
+        // Insert and erase
+        v1.insert_element (0, 55);
+        v1.erase_element (1);
+        v1.clear ();
+    }
+    
+    template<class VP>
+    void test_expression_with (VP &v1, VP &v2, VP &v3) const {
+        // Expression type tests
+        value_type t;
+        size_type i;
+        real_type n;
+
+        // Default Construct
+        default_construct<VP>::test ();
+        
+        // Copy and swap
+        initialize_vector (v1);
+        initialize_vector (v2);
+        v1 = v2;
+        std::cout << "v1 = v2 = " << v1 << std::endl;
+        v1.assign_temporary (v2);
+        std::cout << "v1.assign_temporary (v2) = " << v1 << std::endl;
+        v1.swap (v2);
+        std::cout << "v1.swap (v2) = " << v1 << " " << v2 << std::endl;
+        
+        // Zero assignment
+        v1 = ublas::zero_vector<> (v1.size ());
+        std::cout << "v1.zero_vector = " << v1 << std::endl;
+        v1 = v2;
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+            // Project range and slice
+        initialize_vector (v1);
+        initialize_vector (v2);
+        project (v1, ublas::range(0,1)) = project (v2, ublas::range(0,1));
+        project (v1, ublas::range(0,1)) = project (v2, ublas::slice(0,1,1));
+        project (v1, ublas::slice(2,-1,2)) = project (v2, ublas::slice(0,1,2));
+        project (v1, ublas::slice(2,-1,2)) = project (v2, ublas::range(0,2));
+        std::cout << "v1 = range/slice " << v1 << std::endl;
+#endif
+
+            // Unary vector operations resulting in a vector
+        initialize_vector (v1);
+        v2 = - v1;
+        std::cout << "- v1 = " << v2 << std::endl;
+        v2 = ublas::conj (v1);
+        std::cout << "conj (v1) = " << v2 << std::endl;
+
+        // Binary vector operations resulting in a vector
+        initialize_vector (v1);
+        initialize_vector (v2);
+        v3 = v1 + v2;
+        std::cout << "v1 + v2 = " << v3 << std::endl;
+        v3 = v1 - v2;
+        std::cout << "v1 - v2 = " << v3 << std::endl;
+        v3 = ublas::element_prod (v1, v2);
+        std::cout << "element_prod (v1, v2) = " << v3 << std::endl;
+
+        // Scaling a vector
+        t = N;
+        initialize_vector (v1);
+        v2 = value_type (1.) * v1;
+        std::cout << "1. * v1 = " << v2 << std::endl;
+        v2 = t * v1;
+        std::cout << "N * v1 = " << v2 << std::endl;
+        initialize_vector (v1);
+        v2 = v1 * value_type (1.);
+        std::cout << "v1 * 1. = " << v2 << std::endl;
+        v2 = v1 * t;
+	  std::cout << "v1 * value_type(N) = " << v2 << std::endl;
+	  // test interop with integer
+	  v2 = v1 * N;
+
+        std::cout << "v1 * N = " << v2 << std::endl;
+
+        // Some assignments
+        initialize_vector (v1);
+        initialize_vector (v2);
+        v2 += v1;
+        std::cout << "v2 += v1 = " << v2 << std::endl;
+        v2 -= v1;
+        std::cout << "v2 -= v1 = " << v2 << std::endl;
+        v2 = v2 + v1;
+        std::cout << "v2 = v2 + v1 = " << v2 << std::endl;
+        v2 = v2 - v1;
+        std::cout << "v2 = v2 - v1 = " << v2 << std::endl;
+        v1 *= value_type (1.);
+        std::cout << "v1 *= 1. = " << v1 << std::endl;
+        v1 *= t;
+	  std::cout << "v1 *= value_type(N) = " << v1 << std::endl;
+	  // test interop with integer
+	  v1 *= N;
+        std::cout << "v1 *= N = " << v1 << std::endl;
+
+        // Unary vector operations resulting in a scalar
+        initialize_vector (v1);
+        t = ublas::sum (v1);
+        std::cout << "sum (v1) = " << t << std::endl;
+        n = ublas::norm_1 (v1);
+        std::cout << "norm_1 (v1) = " << n << std::endl;
+        n = ublas::norm_2 (v1);
+        std::cout << "norm_2 (v1) = " << n << std::endl;
+        n = ublas::norm_inf (v1);
+        std::cout << "norm_inf (v1) = " << n << std::endl;
+
+        i = ublas::index_norm_inf (v1);
+        std::cout << "index_norm_inf (v1) = " << i << std::endl;
+
+        // Binary vector operations resulting in a scalar
+        initialize_vector (v1);
+        initialize_vector (v2);
+        t = ublas::inner_prod (v1, v2);
+        std::cout << "inner_prod (v1, v2) = " << t << std::endl;
+
+        // Scalar and Binary vector expression resulting in a vector
+        initialize_vector (v1);
+        initialize_vector (v2);
+        v1 = v1 * ublas::inner_prod (v1, v2);
+        std::cout << "v1 * inner_prod (v1, v2) = " << v1 << std::endl;
+    }
+
+    void operator () () const {
+        V v1 (N), v2 (N), v3 (N);
+        test_expression_with (v1, v2, v3);
+        test_container_with (v1);
+
+#ifdef USE_RANGE
+        ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
+                               vr2 (v2, ublas::range (0, N)),
+                               vr3 (v3, ublas::range (0, N));
+        test_expression_with (vr1, vr2, vr3);
+#endif
+
+#ifdef USE_SLICE
+        ublas::vector_slice<V> vs1 (v1, ublas::slice (0, 1, N)),
+                               vs2 (v2, ublas::slice (0, 1, N)),
+                               vs3 (v3, ublas::slice (0, 1, N));
+        test_expression_with (vs1, vs2, vs3);
+#endif
+    }
+};
+
+// Test vector
+void test_vector () {
+    std::cout << "test_vector" << std::endl;
+
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >, 3 > () ();
+
+
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >, 3 > () ();
+
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >, 3 > () ();
+
+    std::cout << "mp_test_type, bounded" << std::endl;
+    test_my_vector<ublas::bounded_vector<mp_test_type, 3>, 3> () ();
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test12.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test12.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,102 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test1.hpp"
+
+// Test matrix & vector expression templates
+template<class V, class M, int N>
+struct test_my_matrix_vector {
+    typedef typename V::value_type value_type;
+
+    template<class VP, class MP>
+    void test_with (VP &v1, VP &v2, MP &m1) const {
+        {
+            // Rows and columns
+            initialize_matrix (m1);
+            for (int i = 0; i < N; ++ i) {
+                v1 = ublas::row (m1, i);
+                std::cout << "row (m, " << i << ") = " << v1 << std::endl;
+                v1 = ublas::column (m1, i);
+                std::cout << "column (m, " << i << ") = " << v1 << std::endl;
+            }
+
+            // Outer product
+            initialize_vector (v1);
+            initialize_vector (v2);
+            m1 = ublas::outer_prod (v1, v2);
+            std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
+
+            // Matrix vector product
+            initialize_matrix (m1);
+            initialize_vector (v1);
+            v2 = ublas::prod (m1, v1);
+            std::cout << "prod (m1, v1) = " << v2 << std::endl;
+            v2 = ublas::prod (v1, m1);
+            std::cout << "prod (v1, m1) = " << v2 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            test_with (v1, v2, m1);
+
+            ublas::matrix_row<M> mr1 (m1, 0), mr2 (m1, 1);
+            test_with (mr1, mr2, m1);
+
+            ublas::matrix_column<M> mc1 (m1, 0), mc2 (m1, 1);
+            test_with (mc1, mc2, m1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                          mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, m1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                          mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, m1);
+#endif
+        }
+    }
+};
+
+// Test matrix & vector
+void test_matrix_vector () {
+    std::cout << "test_matrix_vector" << std::endl;
+
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
+    std::cout << "mp_test_type, bounded" << std::endl;
+    test_my_matrix_vector<ublas::bounded_vector<mp_test_type, 3>,
+                          ublas::bounded_matrix<mp_test_type, 3, 3>, 3> () ();
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::bounded_array<ublas::bounded_array<mp_test_type, 3>, 3 + 1> >, 3> () ();
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<mp_test_type> > >, 3> () ();
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    /*
+    // This fails with an internal std lib assersion, even when mp_test_type is double,
+    // looks like a bug in the uBlas test code...
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::vector_of_vector<mp_test_type, ublas::row_major, std::vector<std::vector<mp_test_type> > >, 3> () ();*/
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test13.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test13.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,167 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test1.hpp"
+
+// Test matrix expression templates
+template<class M, int N>
+struct test_my_matrix {
+    typedef typename M::value_type value_type;
+
+    template<class VP>
+    void test_container_with (VP &v1) const {
+        // Container type tests in addition to expression types
+        // Insert and erase
+        v1.insert_element (0,0, 55);
+        v1.erase_element (1,1);
+        v1.clear ();
+    }
+    
+    template<class MP>
+    void test_expression_with (MP &m1, MP &m2, MP &m3) const {
+        value_type t;
+
+        // Default Construct
+        default_construct<MP>::test ();
+        
+        // Copy and swap
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        m1 = m2;
+        std::cout << "m1 = m2 = " << m1 << std::endl;
+        m1.assign_temporary (m2);
+        std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
+        m1.swap (m2);
+        std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
+
+        // Zero assignment
+        m1 = ublas::zero_matrix<> (m1.size1 (), m1.size2 ());
+        std::cout << "m1.zero_matrix = " << m1 << std::endl;
+        m1 = m2;
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+            // Project range and slice
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        project (m1, ublas::range(0,1),ublas::range(0,1)) = project (m2, ublas::range(0,1),ublas::range(0,1));
+        project (m1, ublas::range(0,1),ublas::range(0,1)) = project (m2, ublas::slice(0,1,1),ublas::slice(0,1,1));
+        project (m1, ublas::slice(2,-1,2),ublas::slice(2,-1,2)) = project (m2, ublas::slice(0,1,2),ublas::slice(0,1,2));
+        project (m1, ublas::slice(2,-1,2),ublas::slice(2,-1,2)) = project (m2, ublas::range(0,2),ublas::range(0,2));
+        std::cout << "m1 = range/slice " << m1 << std::endl;
+#endif
+
+            // Unary matrix operations resulting in a matrix
+        initialize_matrix (m1);
+        m2 = - m1;
+        std::cout << "- m1 = " << m2 << std::endl;
+        m2 = ublas::conj (m1);
+        std::cout << "conj (m1) = " << m2 << std::endl;
+
+        // Binary matrix operations resulting in a matrix
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        m3 = m1 + m2;
+        std::cout << "m1 + m2 = " << m3 << std::endl;
+        m3 = m1 - m2;
+        std::cout << "m1 - m2 = " << m3 << std::endl;
+        m3 = ublas::element_prod (m1, m2);
+        std::cout << "element_prod (m1, m2) = " << m3 << std::endl;
+
+        // Scaling a matrix
+        t = N;
+        initialize_matrix (m1);
+        m2 = value_type (1.) * m1;
+        std::cout << "1. * m1 = " << m2 << std::endl;
+        m2 = t * m1;
+        std::cout << "N * m1 = " << m2 << std::endl;
+        initialize_matrix (m1);
+        m2 = m1 * value_type (1.);
+        std::cout << "m1 * 1. = " << m2 << std::endl;
+        m2 = m1 * t;
+        std::cout << "m1 * N = " << m2 << std::endl;
+
+        // Some assignments
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        m2 += m1;
+        std::cout << "m2 += m1 = " << m2 << std::endl;
+        m2 -= m1;
+        std::cout << "m2 -= m1 = " << m2 << std::endl;
+        m2 = m2 + m1;
+        std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
+        m2 = m2 - m1;
+        std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
+        m1 *= value_type (1.);
+        std::cout << "m1 *= 1. = " << m1 << std::endl;
+        m1 *= t;
+        std::cout << "m1 *= N = " << m1 << std::endl;
+
+        // Transpose
+        initialize_matrix (m1);
+        m2 = ublas::trans (m1);
+        std::cout << "trans (m1) = " << m2 << std::endl;
+
+        // Hermitean
+        initialize_matrix (m1);
+        m2 = ublas::herm (m1);
+        std::cout << "herm (m1) = " << m2 << std::endl;
+
+        // Matrix multiplication
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        m3 = ublas::prod (m1, m2);
+        std::cout << "prod (m1, m2) = " << m3 << std::endl;
+    }
+
+    void operator () () const {
+        M m1 (N, N), m2 (N, N), m3 (N, N);
+        test_expression_with (m1, m2, m3);
+        test_container_with (m1);
+
+#ifdef USE_RANGE
+        ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                               mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
+                               mr3 (m3, ublas::range (0, N), ublas::range (0, N));
+        test_expression_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+        ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                               ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                               ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+        test_expression_with (ms1, ms2, ms3);
+#endif
+    }
+};
+
+// Test matrix
+void test_matrix () {
+    std::cout << "test_matrix" << std::endl;
+
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix<ublas::matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix<ublas::matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix<ublas::matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
+    std::cout << "mp_test_type, bounded" << std::endl;
+    test_my_matrix<ublas::bounded_matrix<mp_test_type, 3, 3>, 3> () ();
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::bounded_array<ublas::bounded_array<mp_test_type, 3>, 3 + 1> >, 3> () ();
+    /*
+    // This fails with an internal std lib assersion, even when mp_test_type is double,
+    // looks like a bug in the uBlas test code...
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<mp_test_type, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<mp_test_type> > >, 3> () ();
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<mp_test_type, ublas::row_major, std::vector<std::vector<mp_test_type > > >, 3> () ();*/
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,87 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test2.hpp"
+
+int main () {
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type" << std::endl;
+    test_blas_1<ublas::vector<mp_test_type>, 3> ().test ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double" << std::endl;
+    test_blas_1<ublas::vector<double>, 3> ().test ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>" << std::endl;
+    test_blas_1<ublas::vector<std::complex<mp_test_type> >, 3> ().test ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>" << std::endl;
+    test_blas_1<ublas::vector<std::complex<double> >, 3> ().test ();
+#endif
+#endif
+
+    std::cout << "test_blas_2" << std::endl;
+
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type" << std::endl;
+    test_blas_2<ublas::vector<mp_test_type>, ublas::matrix<mp_test_type>, 3> ().test ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double" << std::endl;
+    test_blas_2<ublas::vector<double>, ublas::matrix<double>, 3> ().test ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>" << std::endl;
+    test_blas_2<ublas::vector<std::complex<mp_test_type> >, ublas::matrix<std::complex<mp_test_type> >, 3> ().test ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>" << std::endl;
+    test_blas_2<ublas::vector<std::complex<double> >, ublas::matrix<std::complex<double> >, 3> ().test ();
+#endif
+#endif
+
+    std::cout << "test_blas_3" << std::endl;
+
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type" << std::endl;
+    test_blas_3<ublas::matrix<mp_test_type>, 3> ().test ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double" << std::endl;
+    test_blas_3<ublas::matrix<double>, 3> ().test ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>" << std::endl;
+    test_blas_3<ublas::matrix<std::complex<mp_test_type> >, 3> ().test ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>" << std::endl;
+    test_blas_3<ublas::matrix<std::complex<double> >, 3> ().test ();
+#endif
+#endif
+
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test2.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,69 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST2_H
+#define TEST2_H
+
+#ifdef _MSC_VER
+#  pragma warning(disable:4800 4996)
+#endif
+
+#include <boost/multiprecision/cpp_dec_float.hpp>
+
+typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+//typedef double mp_test_type;
+
+#define USE_RANGE
+#define USE_SLICE
+#define USE_FLOAT
+#define USE_RANGE 
+#define USE_SLICE
+#define USE_UNBOUNDED_ARRAY 
+#define USE_STD_VECTOR 
+#define USE_BOUNDED_VECTOR USE_MATRIX
+
+#include <iostream>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/triangular.hpp>
+#include <boost/numeric/ublas/io.hpp>
+#include <boost/numeric/ublas/blas.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+template<class V, int N>
+struct test_blas_1 {
+    typedef typename V::value_type value_type;
+    typedef typename ublas::type_traits<value_type>::real_type real_type;
+
+    void test ();
+};
+
+template<class V, class M, int N>
+struct test_blas_2 {
+    typedef typename V::value_type value_type;
+
+    void test ();
+};
+
+template<class M, int N>
+struct test_blas_3 {
+    typedef typename M::value_type value_type;
+
+    void test ();
+};
+
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test21.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test21.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,95 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test2.hpp"
+
+template<class V, int N>
+void test_blas_1<V, N>::test () {
+    {
+        value_type t;
+        real_type n;
+        V v1 (N), v2 (N);
+
+        // _asum
+        initialize_vector (v1);
+        n = ublas::blas_1::asum (v1);
+        std::cout << "asum (v1) = " << n << std::endl;
+
+        // _amax
+        initialize_vector (v1);
+        n = ublas::blas_1::amax (v1);
+        std::cout << "amax (v1) = " << n << std::endl;
+
+        // _nrm2
+        initialize_vector (v1);
+        n = ublas::blas_1::nrm2 (v1);
+        std::cout << "nrm2 (v1) = " << n << std::endl;
+
+        // _dot
+        // _dotu
+        // _dotc
+        initialize_vector (v1);
+        initialize_vector (v2);
+        t = ublas::blas_1::dot (v1, v2);
+        std::cout << "dot (v1, v2) = " << t << std::endl;
+        t = ublas::blas_1::dot (ublas::conj (v1), v2);
+        std::cout << "dot (conj (v1), v2) = " << t << std::endl;
+
+        // _copy
+        initialize_vector (v2);
+        ublas::blas_1::copy (v1, v2);
+        std::cout << "copy (v1, v2) = " << v1 << std::endl;
+
+        // _swap
+        initialize_vector (v1);
+        initialize_vector (v2);
+        ublas::blas_1::swap (v1, v2);
+        std::cout << "swap (v1, v2) = " << v1 << " " << v2 << std::endl;
+
+        // _scal
+        // csscal
+        // zdscal
+        initialize_vector (v1);
+        ublas::blas_1::scal (v1, value_type (1));
+        std::cout << "scal (v1, 1) = " << v1 << std::endl;
+
+        // _axpy
+        initialize_vector (v1);
+        initialize_vector (v2);
+        ublas::blas_1::axpy (v1, value_type (1), v2);
+        std::cout << "axpy (v1, 1, v2) = " << v1 << std::endl;
+
+        // _rot
+        initialize_vector (v1);
+        initialize_vector (v2);
+        ublas::blas_1::rot (value_type (1), v1, value_type (1), v2);
+        std::cout << "rot (1, v1, 1, v2) = " << v1 << " " << v2 << std::endl;
+    }
+}
+
+#ifdef USE_FLOAT
+template struct test_blas_1<ublas::vector<mp_test_type>, 3>;
+#endif
+
+#ifdef USE_DOUBLE
+template struct test_blas_1<ublas::vector<double>, 3>;
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+template struct test_blas_1<ublas::vector<std::complex<mp_test_type> >, 3>;
+#endif
+
+#ifdef USE_DOUBLE
+template struct test_blas_1<ublas::vector<std::complex<double> >, 3>;
+#endif
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test22.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test22.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,147 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test2.hpp"
+
+template<class V, class M, int N>
+void test_blas_2<V, M, N>::test () {
+    {
+        V v1 (N), v2 (N);
+        M m (N, N);
+
+        // _t_mv
+        initialize_vector (v1);
+        initialize_matrix (m);
+        ublas::blas_2::tmv (v1, m);
+        std::cout << "tmv (v1, m) = " << v1 << std::endl;
+        initialize_vector (v1);
+        initialize_matrix (m);
+        ublas::blas_2::tmv (v1, ublas::trans (m));
+        std::cout << "tmv (v1, trans (m)) = " << v1 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_vector (v1);
+        initialize_matrix (m);
+        ublas::blas_2::tmv (v1, ublas::herm (m));
+        std::cout << "tmv (v1, herm (m)) = " << v1 << std::endl;
+#endif
+
+        // _t_sv
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m, ublas::lower_tag ());
+        ublas::blas_2::tsv (v1, m, ublas::lower_tag ());
+        std::cout << "tsv (v1, m) = " << v1 << " " << ublas::prod (m, v1) - v2 << std::endl;
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m, ublas::upper_tag ());
+        ublas::blas_2::tsv (v1, ublas::trans (m), ublas::lower_tag ());
+        std::cout << "tsv (v1, trans (m)) = " << v1 << " " << ublas::prod (ublas::trans (m), v1) - v2 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m, ublas::upper_tag ());
+        ublas::blas_2::tsv (v1, ublas::herm (m), ublas::lower_tag ());
+        std::cout << "tsv (v1, herm (m)) = " << v1 << " " << ublas::prod (ublas::herm (m), v1) - v2 << std::endl;
+#endif
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m, ublas::upper_tag ());
+        ublas::blas_2::tsv (v1, m, ublas::upper_tag ());
+        std::cout << "tsv (v1, m) = " << v1 << " " << ublas::prod (m, v1) - v2 << std::endl;
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m, ublas::lower_tag ());
+        ublas::blas_2::tsv (v1, ublas::trans (m), ublas::upper_tag ());
+        std::cout << "tsv (v1, trans (m)) = " << v1 << " " << ublas::prod (ublas::trans (m), v1) - v2 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m, ublas::lower_tag ());
+        ublas::blas_2::tsv (v1, ublas::herm (m), ublas::upper_tag ());
+        std::cout << "tsv (v1, herm (m)) = " << v1 << " " << ublas::prod (ublas::herm (m), v1) - v2 << std::endl;
+#endif
+
+        // _g_mv
+        // _s_mv
+        // _h_mv
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m);
+        ublas::blas_2::gmv (v1, value_type (1), value_type (1), m, v2);
+        std::cout << "gmv (v1, 1, 1, m, v2) = " << v1 << std::endl;
+        ublas::blas_2::gmv (v1, value_type (1), value_type (1), ublas::trans (m), v2);
+        std::cout << "gmv (v1, 1, 1, trans (m), v2) = " << v1 << std::endl;
+#ifdef USE_STD_COMPLEX
+        ublas::blas_2::gmv (v1, value_type (1), value_type (1), ublas::herm (m), v2);
+        std::cout << "gmv (v1, 1, 1, herm (m), v2) = " << v1 << std::endl;
+#endif
+
+        // _g_r
+        // _g_ru
+        // _g_rc
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m);
+        ublas::blas_2::gr (m, value_type (1), v1, v2);
+        std::cout << "gr (m, 1, v1, v2) = " << m << std::endl;
+        ublas::blas_2::gr (m, value_type (1), v1, ublas::conj (v2));
+        std::cout << "gr (m, 1, v1, conj (v2)) = " << m << std::endl;
+
+        // _s_r
+        initialize_vector (v1);
+        initialize_matrix (m);
+        ublas::blas_2::sr (m, value_type (1), v1);
+        std::cout << "sr (m, 1, v1) = " << m << std::endl;
+
+#ifdef USE_STD_COMPLEX
+        // _h_r
+        initialize_vector (v1);
+        initialize_matrix (m);
+        ublas::blas_2::hr (m, value_type (1), v1);
+        std::cout << "hr (m, 1, v1) = " << m << std::endl;
+#endif
+
+        // _s_r2
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m);
+        ublas::blas_2::sr2 (m, value_type (1), v1, v2);
+        std::cout << "sr2 (m, 1, v1, v2) = " << m << std::endl;
+
+#ifdef USE_STD_COMPLEX
+        // _h_r2
+        initialize_vector (v1);
+        initialize_vector (v2);
+        initialize_matrix (m);
+        ublas::blas_2::hr2 (m, value_type (1), v1, v2);
+        std::cout << "hr2 (m, 1, v1, v2) = " << m << std::endl;
+#endif
+    }
+}
+
+#ifdef USE_FLOAT
+template struct test_blas_2<ublas::vector<mp_test_type>, ublas::matrix<mp_test_type>, 3>;
+#endif
+
+#ifdef USE_DOUBLE
+template struct test_blas_2<ublas::vector<double>, ublas::matrix<double>, 3>;
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+template struct test_blas_2<ublas::vector<std::complex<mp_test_type> >, ublas::matrix<std::complex<mp_test_type> >, 3>;
+#endif
+
+#ifdef USE_DOUBLE
+template struct test_blas_2<ublas::vector<std::complex<double> >, ublas::matrix<std::complex<double> >, 3>;
+#endif
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test23.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test23.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,208 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test2.hpp"
+
+template<class M, int N>
+void test_blas_3<M, N>::test () {
+    {
+        M m1 (N, N), m2 (N, N), m3 (N, N);
+
+        // _t_mm
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), m2, m1);
+        std::cout << "tmm (m1, 1, m2, m1) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), m2, ublas::trans (m1));
+        std::cout << "tmm (m1, 1, m2, trans (m1)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), ublas::trans (m2), m1);
+        std::cout << "tmm (m1, 1, trans (m2), m1) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), ublas::trans (m2), ublas::trans (m1));
+        std::cout << "tmm (m1, 1, trans (m2), trans (m1)) = " << m1 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), m2, ublas::herm (m1));
+        std::cout << "tmm (m1, 1, m2, herm (m1)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), ublas::herm (m2), m1);
+        std::cout << "tmm (m1, 1, herm (m2), m1) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), ublas::trans (m2), ublas::herm (m1));
+        std::cout << "tmm (m1, 1, trans (m2), herm (m1)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), ublas::herm (m2), ublas::trans (m1));
+        std::cout << "tmm (m1, 1, herm (m2), trans (m1)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::tmm (m1, value_type (1), ublas::herm (m2), ublas::herm (m1));
+        std::cout << "tmm (m1, 1, herm (m2), herm (m1)) = " << m1 << std::endl;
+#endif
+
+        // _t_sm
+        initialize_matrix (m1);
+        initialize_matrix (m2, ublas::lower_tag ());
+        initialize_matrix (m3);
+        ublas::blas_3::tsm (m1, value_type (1), m2, ublas::lower_tag ());
+        std::cout << "tsm (m1, 1, m2) = " << m1 << " " << ublas::prod (m2, m1) - value_type (1) * m3 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2, ublas::upper_tag ());
+        ublas::blas_3::tsm (m1, value_type (1), ublas::trans (m2), ublas::lower_tag ());
+        std::cout << "tsm (m1, 1, trans (m2)) = " << m1 << " " << ublas::prod (ublas::trans (m2), m1) - value_type (1) * m3 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_matrix (m1);
+        initialize_matrix (m2, ublas::upper_tag ());
+        ublas::blas_3::tsm (m1, value_type (1), ublas::herm (m2), ublas::lower_tag ());
+        std::cout << "tsm (m1, 1, herm (m2)) = " << m1 << " " << ublas::prod (ublas::herm (m2), m1) - value_type (1) * m3 << std::endl;
+#endif
+        initialize_matrix (m1);
+        initialize_matrix (m2, ublas::upper_tag ());
+        ublas::blas_3::tsm (m1, value_type (1), m2, ublas::upper_tag ());
+        std::cout << "tsm (m1, 1, m2) = " << m1 << " " << ublas::prod (m2, m1) - value_type (1) * m3 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2, ublas::lower_tag ());
+        ublas::blas_3::tsm (m1, value_type (1), ublas::trans (m2), ublas::upper_tag ());
+        std::cout << "tsm (m1, 1, trans (m2)) = " << m1 << " " << ublas::prod (ublas::trans (m2), m1) - value_type (1) * m3 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_matrix (m1);
+        initialize_matrix (m2, ublas::lower_tag ());
+        ublas::blas_3::tsm (m1, value_type (1), ublas::herm (m2), ublas::upper_tag ());
+        std::cout << "tsm (m1, 1, herm (m2)) = " << m1 << " " << ublas::prod (ublas::herm (m2), m1) - value_type (1) * m3 << std::endl;
+#endif
+
+        // _g_mm
+        // _s_mm
+        // _h_mm
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), m2, m3);
+        std::cout << "gmm (m1, 1, 1, m2, m3) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), ublas::trans (m2), m3);
+        std::cout << "gmm (m1, 1, 1, trans (m2), m3) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), m2, ublas::trans (m3));
+        std::cout << "gmm (m1, 1, 1, m2, trans (m3)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), ublas::trans (m2), ublas::trans (m3));
+        std::cout << "gmm (m1, 1, 1, trans (m2), trans (m3)) = " << m1 << std::endl;
+#ifdef USE_STD_COMPLEX
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), ublas::herm (m2), m3);
+        std::cout << "gmm (m1, 1, 1, herm (m2), m3) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), m2, ublas::herm (m3));
+        std::cout << "gmm (m1, 1, 1, m2, herm (m3)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), ublas::herm (m2), ublas::trans (m3));
+        std::cout << "gmm (m1, 1, 1, herm (m2), trans (m3)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), ublas::trans (m2), ublas::herm (m3));
+        std::cout << "gmm (m1, 1, 1, trans (m2), herm (m3)) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::gmm (m1, value_type (1), value_type (1), ublas::herm (m2), ublas::herm (m3));
+        std::cout << "gmm (m1, 1, 1, herm (m2), herm (m3)) = " << m1 << std::endl;
+#endif
+
+        // s_rk
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::srk (m1, value_type (1), value_type (1), m2);
+        std::cout << "srk (m1, 1, 1, m2) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::srk (m1, value_type (1), value_type (1), ublas::trans (m2));
+        std::cout << "srk (m1, 1, 1, trans (m2)) = " << m1 << std::endl;
+
+#ifdef USE_STD_COMPLEX
+        // h_rk
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::hrk (m1, value_type (1), value_type (1), m2);
+        std::cout << "hrk (m1, 1, 1, m2) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        ublas::blas_3::hrk (m1, value_type (1), value_type (1), ublas::herm (m2));
+        std::cout << "hrk (m1, 1, 1, herm (m2)) = " << m1 << std::endl;
+#endif
+
+        // s_r2k
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::sr2k (m1, value_type (1), value_type (1), m2, m3);
+        std::cout << "sr2k (m1, 1, 1, m2, m3) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::sr2k (m1, value_type (1), value_type (1), ublas::trans (m2), ublas::trans (m3));
+        std::cout << "sr2k (m1, 1, 1, trans (m2), trans (m3)) = " << m1 << std::endl;
+
+#ifdef USE_STD_COMPLEX
+        // h_r2k
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::hr2k (m1, value_type (1), value_type (1), m2, m3);
+        std::cout << "hr2k (m1, 1, 1, m2, m3) = " << m1 << std::endl;
+        initialize_matrix (m1);
+        initialize_matrix (m2);
+        initialize_matrix (m3);
+        ublas::blas_3::hr2k (m1, value_type (1), value_type (1), ublas::herm (m2), ublas::herm (m3));
+        std::cout << "hr2k (m1, 1, 1, herm (m2), herm (m3)) = " << m1 << std::endl;
+#endif
+    }
+}
+
+#ifdef USE_FLOAT
+template struct test_blas_3<ublas::matrix<mp_test_type>, 3>;
+#endif
+
+#ifdef USE_DOUBLE
+template struct test_blas_3<ublas::matrix<double>, 3>;
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+template struct test_blas_3<ublas::matrix<std::complex<mp_test_type> >, 3>;
+#endif
+
+#ifdef USE_DOUBLE
+template struct test_blas_3<ublas::matrix<std::complex<double> >, 3>;
+#endif
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,20 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test3.hpp"
+
+int main () {
+    test_vector ();
+    test_matrix_vector ();
+    test_matrix ();
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test3.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,63 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST3_H
+#define TEST3_H
+
+#ifdef _MSC_VER
+#  pragma warning(disable:4800 4996)
+#endif
+
+#include <boost/multiprecision/cpp_dec_float.hpp>
+
+typedef boost::multiprecision::mp_number<boost::multiprecision::cpp_dec_float<50>, false> mp_test_type;
+//typedef double mp_test_type;
+
+#define USE_RANGE
+#define USE_SLICE
+#define USE_FLOAT
+#define USE_UNBOUNDED_ARRAY 
+#define USE_STD_VECTOR 
+#define USE_BOUNDED_VECTOR USE_MATRIX
+#define USE_UNBOUNDED_ARRAY
+#define USE_MAP_ARRAY 
+#define USE_STD_MAP
+#define USE_MAPPED_VECTOR 
+#define USE_COMPRESSED_VECTOR 
+#define USE_COORDINATE_VECTOR
+#define USE_MAPPED_MATRIX 
+#define USE_COMPRESSED_MATRIX 
+#define USE_COORDINATE_MATRIX
+
+#include <iostream>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/vector_proxy.hpp>
+#include <boost/numeric/ublas/vector_sparse.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/matrix_proxy.hpp>
+#include <boost/numeric/ublas/matrix_sparse.hpp>
+#include <boost/numeric/ublas/vector_sparse.hpp>
+#ifdef USE_GENERALIZED_VECTOR_OF_VECTOR
+#include <boost/numeric/ublas/vector_of_vector.hpp>
+#endif
+#include <boost/numeric/ublas/io.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+void test_vector ();
+void test_matrix_vector ();
+void test_matrix ();
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test31.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test31.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,248 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test3.hpp"
+
+// Test vector expression templates
+template<class V, int N>
+struct test_my_vector {
+    typedef typename V::value_type value_type;
+    typedef typename V::size_type size_type;
+    typedef typename ublas::type_traits<value_type>::real_type real_type;
+
+    template<class VP>
+    void test_with (VP &v1, VP &v2, VP &v3) const {
+        {
+            value_type t;
+            size_type i;
+            real_type n;
+
+            // Default Construct
+            default_construct<VP>::test ();
+            
+            // Copy and swap
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v1 = v2;
+            std::cout << "v1 = v2 = " << v1 << std::endl;
+            v1.assign_temporary (v2);
+            std::cout << "v1.assign_temporary (v2) = " << v1 << std::endl;
+            v1.swap (v2);
+            std::cout << "v1.swap (v2) = " << v1 << " " << v2 << std::endl;
+
+            // Zero assignment
+            v1 = ublas::zero_vector<> (v1.size ());
+            std::cout << "v1.zero_vector = " << v1 << std::endl;
+            v1 = v2;
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+            // Project range and slice
+            initialize_vector (v1);
+            initialize_vector (v2);
+            project (v1, ublas::range(0,1)) = project (v2, ublas::range(0,1));
+            project (v1, ublas::range(0,1)) = project (v2, ublas::slice(0,1,1));
+            project (v1, ublas::slice(2,-1,2)) = project (v2, ublas::slice(0,1,2));
+            project (v1, ublas::slice(2,-1,2)) = project (v2, ublas::range(0,2));
+            std::cout << "v1 = range/slice " << v1 << std::endl;
+#endif
+
+            // Unary vector operations resulting in a vector
+            initialize_vector (v1);
+            v2 = - v1;
+            std::cout << "- v1 = " << v2 << std::endl;
+            v2 = ublas::conj (v1);
+            std::cout << "conj (v1) = " << v2 << std::endl;
+
+            // Binary vector operations resulting in a vector
+            initialize_vector (v1);
+            initialize_vector (v2);
+            initialize_vector (v3);
+            v3 = v1 + v2;
+            std::cout << "v1 + v2 = " << v3 << std::endl;
+
+            v3 = v1 - v2;
+            std::cout << "v1 - v2 = " << v3 << std::endl;
+
+            // Scaling a vector
+            t = N;
+            initialize_vector (v1);
+            v2 = value_type (1.) * v1;
+            std::cout << "1. * v1 = " << v2 << std::endl;
+            v2 = t * v1;
+            std::cout << "N * v1 = " << v2 << std::endl;
+            initialize_vector (v1);
+            v2 = v1 * value_type (1.);
+            std::cout << "v1 * 1. = " << v2 << std::endl;
+            v2 = v1 * t;
+            std::cout << "v1 * N = " << v2 << std::endl;
+
+            // Some assignments
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v2 += v1;
+            std::cout << "v2 += v1 = " << v2 << std::endl;
+            v2 -= v1;
+            std::cout << "v2 -= v1 = " << v2 << std::endl;
+            v2 = v2 + v1;
+            std::cout << "v2 = v2 + v1 = " << v2 << std::endl;
+            v2 = v2 - v1;
+            std::cout << "v2 = v2 - v1 = " << v2 << std::endl;
+            v1 *= value_type (1.);
+            std::cout << "v1 *= 1. = " << v1 << std::endl;
+            v1 *= t;
+            std::cout << "v1 *= N = " << v1 << std::endl;
+
+            // Unary vector operations resulting in a scalar
+            initialize_vector (v1);
+            t = ublas::sum (v1);
+            std::cout << "sum (v1) = " << t << std::endl;
+            n = ublas::norm_1 (v1);
+            std::cout << "norm_1 (v1) = " << n << std::endl;
+            n = ublas::norm_2 (v1);
+            std::cout << "norm_2 (v1) = " << n << std::endl;
+            n = ublas::norm_inf (v1);
+            std::cout << "norm_inf (v1) = " << n << std::endl;
+
+            i = ublas::index_norm_inf (v1);
+            std::cout << "index_norm_inf (v1) = " << i << std::endl;
+
+            // Binary vector operations resulting in a scalar
+            initialize_vector (v1);
+            initialize_vector (v2);
+            t = ublas::inner_prod (v1, v2);
+            std::cout << "inner_prod (v1, v2) = " << t << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N, N), v2 (N, N), v3 (N, N);
+            test_with (v1, v2, v3);
+
+#ifdef USE_RANGE
+            ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
+                                   vr2 (v2, ublas::range (0, N)),
+                                   vr3 (v3, ublas::range (0, N));
+            test_with (vr1, vr2, vr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::vector_slice<V> vs1 (v1, ublas::slice (0, 1, N)),
+                                   vs2 (v2, ublas::slice (0, 1, N)),
+                                   vs3 (v3, ublas::slice (0, 1, N));
+            test_with (vs1, vs2, vs3);
+#endif
+        }
+    }
+};
+
+// Test vector
+void test_vector () {
+    std::cout << "test_vector" << std::endl;
+
+#ifdef USE_SPARSE_VECTOR
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, map_array" << std::endl;
+    test_my_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, map_array" << std::endl;
+    test_my_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, map_array" << std::endl;
+    test_my_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, map_array" << std::endl;
+    test_my_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::map" << std::endl;
+    test_my_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::map" << std::endl;
+    test_my_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::map" << std::endl;
+    test_my_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::map" << std::endl;
+    test_my_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > , 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_COMPRESSED_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type compressed" << std::endl;
+    test_my_vector<ublas::compressed_vector<mp_test_type>, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double compressed" << std::endl;
+    test_my_vector<ublas::compressed_vector<double>, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type> compressed" << std::endl;
+    test_my_vector<ublas::compressed_vector<std::complex<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double> compressed" << std::endl;
+    test_my_vector<ublas::compressed_vector<std::complex<double> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_COORDINATE_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type coordinate" << std::endl;
+    test_my_vector<ublas::coordinate_vector<mp_test_type>, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double coordinate" << std::endl;
+    test_my_vector<ublas::coordinate_vector<double>, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type> coordinate" << std::endl;
+    test_my_vector<ublas::coordinate_vector<std::complex<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double> coordinate" << std::endl;
+    test_my_vector<ublas::coordinate_vector<std::complex<double> >, 3 > () ();
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test32.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test32.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,324 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test3.hpp"
+
+// Test matrix & vector expression templates
+template<class V, class M, int N>
+struct test_my_matrix_vector {
+    typedef typename V::value_type value_type;
+
+    template<class VP, class MP>
+    void test_with (VP &v1, VP &v2, MP &m1) const {
+        {
+            // Rows and columns
+            initialize_matrix (m1);
+            for (int i = 0; i < N; ++ i) {
+                v1 = ublas::row (m1, i);
+                std::cout << "row (m, " << i << ") = " << v1 << std::endl;
+                v1 = ublas::column (m1, i);
+                std::cout << "column (m, " << i << ") = " << v1 << std::endl;
+            }
+
+            // Outer product
+            initialize_vector (v1);
+            initialize_vector (v2);
+            m1 = ublas::outer_prod (v1, v2);
+            std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
+
+            // Matrix vector product
+            initialize_matrix (m1);
+            initialize_vector (v1);
+            v2 = ublas::prod (m1, v1);
+            std::cout << "prod (m1, v1) = " << v2 << std::endl;
+            v2 = ublas::prod (v1, m1);
+            std::cout << "prod (v1, m1) = " << v2 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N, N), v2 (N, N);
+            M m1 (N, N, N * N);
+
+            test_with (v1, v2, m1);
+
+            ublas::matrix_row<M> mr1 (m1, 0), mr2 (m1, N - 1);
+            test_with (mr1, mr2, m1);
+
+            ublas::matrix_column<M> mc1 (m1, 0), mc2 (m1, N - 1);
+            test_with (mc1, mc2, m1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                          mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, m1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                          mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, m1);
+#endif
+        }
+    }
+};
+
+// Test matrix & vector
+void test_matrix_vector () {
+    std::cout << "test_matrix_vector" << std::endl;
+
+#ifdef USE_SPARSE_MATRIX
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
+                          ublas::mapped_matrix<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
+                          ublas::mapped_matrix<double, ublas::row_major, ublas::map_array<std::size_t, double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
+                          ublas::mapped_matrix<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
+                          ublas::mapped_matrix<mp_test_type, ublas::row_major, std::map<std::size_t, mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
+                          ublas::mapped_matrix<double, ublas::row_major, std::map<std::size_t, double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
+                          ublas::mapped_matrix<std::complex<double>, ublas::row_major, std::map<std::size_t, std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_SPARSE_VECTOR_OF_SPARSE_VECTOR
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, mapped_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
+                          ublas::mapped_vector<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, mapped_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
+                          ublas::mapped_vector<double, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, double> > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, mapped_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::mapped_vector<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<mp_test_type> > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>,mapped_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
+                          ublas::mapped_vector<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<double> > > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, mapped_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
+                          ublas::mapped_vector<mp_test_type, ublas::row_major, std::map<std::size_t, std::map<std::size_t, mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, mapped_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
+                          ublas::mapped_vector<double, ublas::row_major, std::map<std::size_t, std::map<std::size_t, double> > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, mapped_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::mapped_vector<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<mp_test_type> > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, mapped_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
+                          ublas::mapped_vector<std::complex<double>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<double> > > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_GENERALIZED_VECTOR_OF_VECTOR
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
+                          ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >,
+                          ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >, ublas::map_array<std::size_t, ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
+                          ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >,
+                          ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >, ublas::map_array<std::size_t, ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
+                          ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >,
+                          ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
+                          ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >,
+                          ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >, std::map<std::size_t, ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
+                          ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, std::map<std::size_t, double> > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >,
+                          ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >, std::map<std::size_t, ublas::mapped_vector<double, std::map<std::size_t, double> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >,
+                          ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
+                          ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > >, 3 > () ();
+    test_my_matrix_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >,
+                          ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_COMPRESSED_MATRIX
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type compressed" << std::endl;
+    test_my_matrix_vector<ublas::compressed_vector<mp_test_type>,
+                          ublas::compressed_matrix<mp_test_type>, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double compressed" << std::endl;
+    test_my_matrix_vector<ublas::compressed_vector<double>,
+                          ublas::compressed_matrix<double>, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type> compressed" << std::endl;
+    test_my_matrix_vector<ublas::compressed_vector<std::complex<mp_test_type> >,
+                          ublas::compressed_matrix<std::complex<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double> compressed" << std::endl;
+    test_my_matrix_vector<ublas::compressed_vector<std::complex<double> >,
+                          ublas::compressed_matrix<std::complex<double> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_COORDINATE_MATRIX
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type coordinate" << std::endl;
+    test_my_matrix_vector<ublas::coordinate_vector<mp_test_type>,
+                          ublas::coordinate_matrix<mp_test_type>, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double coordinate" << std::endl;
+    test_my_matrix_vector<ublas::coordinate_vector<double>,
+                          ublas::coordinate_matrix<double>, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type> coordinate" << std::endl;
+    test_my_matrix_vector<ublas::coordinate_vector<std::complex<mp_test_type> >,
+                          ublas::coordinate_matrix<std::complex<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double> coordinate" << std::endl;
+    test_my_matrix_vector<ublas::coordinate_vector<std::complex<double> >,
+                          ublas::coordinate_matrix<std::complex<double> >, 3 > () ();
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test33.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test33.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,347 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test3.hpp"
+
+// Test matrix expression templates
+template<class M, int N>
+struct test_my_matrix {
+    typedef typename M::value_type value_type;
+
+    template<class MP>
+    void test_with (MP &m1, MP &m2, MP &m3) const {
+        {
+            value_type t;
+
+            // Default Construct
+            default_construct<MP>::test ();
+            
+            // Copy and swap
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m1 = m2;
+            std::cout << "m1 = m2 = " << m1 << std::endl;
+            m1.assign_temporary (m2);
+            std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
+            m1.swap (m2);
+            std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
+
+            // Zero assignment
+            m1 = ublas::zero_matrix<> (m1.size1 (), m1.size2 ());
+            std::cout << "m1.zero_matrix = " << m1 << std::endl;
+            m1 = m2;
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+            // Project range and slice
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            project (m1, ublas::range(0,1),ublas::range(0,1)) = project (m2, ublas::range(0,1),ublas::range(0,1));
+            project (m1, ublas::range(0,1),ublas::range(0,1)) = project (m2, ublas::slice(0,1,1),ublas::slice(0,1,1));
+            project (m1, ublas::slice(2,-1,2),ublas::slice(2,-1,2)) = project (m2, ublas::slice(0,1,2),ublas::slice(0,1,2));
+            project (m1, ublas::slice(2,-1,2),ublas::slice(2,-1,2)) = project (m2, ublas::range(0,2),ublas::range(0,2));
+            std::cout << "m1 = range/slice " << m1 << std::endl;
+#endif
+
+            // Unary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            m2 = - m1;
+            std::cout << "- m1 = " << m2 << std::endl;
+            m2 = ublas::conj (m1);
+            std::cout << "conj (m1) = " << m2 << std::endl;
+
+            // Binary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            initialize_matrix (m3);
+            m3 = m1 + m2;
+            std::cout << "m1 + m2 = " << m3 << std::endl;
+            m3 = m1 - m2;
+            std::cout << "m1 - m2 = " << m3 << std::endl;
+
+            // Scaling a matrix
+            t = N;
+            initialize_matrix (m1);
+            m2 = value_type (1.) * m1;
+            std::cout << "1. * m1 = " << m2 << std::endl;
+            m2 = t * m1;
+            std::cout << "N * m1 = " << m2 << std::endl;
+            initialize_matrix (m1);
+            m2 = m1 * value_type (1.);
+            std::cout << "m1 * 1. = " << m2 << std::endl;
+            m2 = m1 * t;
+            std::cout << "m1 * N = " << m2 << std::endl;
+
+            // Some assignments
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m2 += m1;
+            std::cout << "m2 += m1 = " << m2 << std::endl;
+            m2 -= m1;
+            std::cout << "m2 -= m1 = " << m2 << std::endl;
+            m2 = m2 + m1;
+            std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
+            m2 = m2 - m1;
+            std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
+            m1 *= value_type (1.);
+            std::cout << "m1 *= 1. = " << m1 << std::endl;
+            m1 *= t;
+            std::cout << "m1 *= N = " << m1 << std::endl;
+
+            // Transpose
+            initialize_matrix (m1);
+            m2 = ublas::trans (m1);
+            std::cout << "trans (m1) = " << m2 << std::endl;
+
+            // Hermitean
+            initialize_matrix (m1);
+            m2 = ublas::herm (m1);
+            std::cout << "herm (m1) = " << m2 << std::endl;
+
+            // Matrix multiplication
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = ublas::prod (m1, m2);
+            std::cout << "prod (m1, m2) = " << m3 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            M m1 (N, N, N * N), m2 (N, N, N * N), m3 (N, N, N * N);
+            test_with (m1, m2, m3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                   mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
+                                   mr3 (m3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+    }
+};
+
+// Test matrix
+void test_matrix () {
+    std::cout << "test_matrix" << std::endl;
+
+#ifdef USE_SPARSE_MATRIX
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, mapped_matrix map_array" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, mapped_matrix map_array" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<double, ublas::row_major, ublas::map_array<std::size_t, double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, mapped_matrix map_array" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, mapped_matrix map_array" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, mapped_matrix std::map" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<mp_test_type, ublas::row_major, std::map<std::size_t, mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, mapped_matrix std::map" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<double, ublas::row_major, std::map<std::size_t, double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, mapped_matrix std::map" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, mapped_matrix std::map" << std::endl;
+    test_my_matrix<ublas::mapped_matrix<std::complex<double>, ublas::row_major, std::map<std::size_t, std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_SPARSE_VECTOR_OF_SPARSE_VECTOR
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, mapped_vector_of_mapped_vector map_array" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<mp_test_type, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, mapped_vector_of_mapped_vector map_array" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<double, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, double> > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, mapped_vector_of_mapped_vector map_array" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<mp_test_type>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<mp_test_type> > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, mapped_vector_of_mapped_vectormap_array" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<double>, ublas::row_major, ublas::map_array<std::size_t, ublas::map_array<std::size_t, std::complex<double> > > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, mapped_vector_of_mapped_vector std::map" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<mp_test_type, ublas::row_major, std::map<std::size_t, std::map<std::size_t, mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, mapped_vector_of_mapped_vector std::map" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<double, ublas::row_major, std::map<std::size_t, std::map<std::size_t, double> > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, mapped_vector_of_mapped_vector std::map" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<mp_test_type>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<mp_test_type> > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, mapped_vector_of_mapped_vector std::map" << std::endl;
+    test_my_matrix<ublas::mapped_vector_of_mapped_vector<std::complex<double>, ublas::row_major, std::map<std::size_t, std::map<std::size_t, std::complex<double> > > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_GENERALIZED_VECTOR_OF_VECTOR
+#ifdef USE_MAP_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type,generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> >, ublas::map_array<std::size_t, ublas::mapped_vector<mp_test_type, ublas::map_array<std::size_t, mp_test_type> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, ublas::map_array<std::size_t, double> >, ublas::map_array<std::size_t, ublas::mapped_vector<double, ublas::map_array<std::size_t, double> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, ublas::map_array<std::size_t, std::complex<mp_test_type> > > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, generalized_vector_of_vector map_array" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > >, ublas::map_array<std::size_t, ublas::mapped_vector<std::complex<double>, ublas::map_array<std::size_t, std::complex<double> > > > > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_MAP
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<mp_test_type, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> >, std::map<std::size_t, ublas::mapped_vector<mp_test_type, std::map<std::size_t, mp_test_type> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::vector<ublas::mapped_vector<double, std::map<std::size_t, double> > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<double, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<double, std::map<std::size_t, double> >, std::map<std::size_t, ublas::mapped_vector<double, std::map<std::size_t, double> > > > >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<mp_test_type>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<mp_test_type>, std::map<std::size_t, std::complex<mp_test_type> > > > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, generalized_vector_of_vector std::map" << std::endl;
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > >, 3 > () ();
+    test_my_matrix<ublas::generalized_vector_of_vector<std::complex<double>, ublas::row_major, ublas::mapped_vector<ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > >, std::map<std::size_t, ublas::mapped_vector<std::complex<double>, std::map<std::size_t, std::complex<double> > > > > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_COMPRESSED_MATRIX
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type compressed_matrix" << std::endl;
+    test_my_matrix<ublas::compressed_matrix<mp_test_type>, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double compressed_matrix" << std::endl;
+    test_my_matrix<ublas::compressed_matrix<double>, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type> compressed_matrix" << std::endl;
+    test_my_matrix<ublas::compressed_matrix<std::complex<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double> compressed_matrix" << std::endl;
+    test_my_matrix<ublas::compressed_matrix<std::complex<double> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_COORDINATE_MATRIX
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type coordinate_matrix" << std::endl;
+    test_my_matrix<ublas::coordinate_matrix<mp_test_type>, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double coordinate_matrix" << std::endl;
+    test_my_matrix<ublas::coordinate_matrix<double>, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type> coordinate_matrix" << std::endl;
+    test_my_matrix<ublas::coordinate_matrix<std::complex<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double> coordinate_matrix" << std::endl;
+    test_my_matrix<ublas::coordinate_matrix<std::complex<double> >, 3 > () ();
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,19 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test4.hpp"
+
+int main () {
+    test_matrix_vector ();
+    test_matrix ();
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test4.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,39 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST4_H
+#define TEST4_H
+
+#include <iostream>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/matrix_proxy.hpp>
+#include <boost/numeric/ublas/banded.hpp>
+#include <boost/numeric/ublas/io.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+//#define USE_BANDED
+#define USE_DIAGONAL
+
+
+void test_matrix_vector ();
+void test_matrix ();
+
+
+// FIXME slice are failing in assignment to zero elements
+#undef USE_SLICE
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test42.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test42.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,361 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test4.hpp"
+
+// Test matrix & vector expression templates
+template<class V, class M, int N>
+struct test_my_matrix_vector {
+    typedef typename V::value_type value_type;
+
+    template<class VP, class MP>
+    void test_with (VP &v1, VP &v2, MP &m1) const {
+        {
+#ifndef USE_DIAGONAL
+            // Rows and columns
+            initialize_matrix (m1);
+            for (int i = 0; i < N; ++ i) {
+                v2 = ublas::row (m1, i);
+                std::cout << "row (m, " << i << ") = " << v2 << std::endl;
+                v2 = ublas::column (m1, i);
+                std::cout << "column (m, " << i << ") = " << v2 << std::endl;
+            }
+
+            // Outer product
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v1 (0) = 0;
+            v1 (N - 1) = 0;
+            m1 = ublas::outer_prod (v1, v2);
+            std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
+
+            // Matrix vector product
+            initialize_matrix (m1);
+            initialize_vector (v1);
+            v2 = ublas::prod (m1, v1);
+            std::cout << "prod (m1, v1) = " << v2 << std::endl;
+            v2 = ublas::prod (v1, m1);
+            std::cout << "prod (v1, m1) = " << v2 << std::endl;
+#endif
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N), v2 (N);
+#ifdef USE_BANDED
+            M m1 (N, N, 1, 1);
+#endif
+#ifdef USE_DIAGONAL
+            M m1 (N, N);
+#endif
+            test_with (v1, v2, m1);
+
+            ublas::matrix_row<M> mr1 (m1, 1), mr2 (m1, 1);
+            test_with (mr1, mr2, m1);
+
+            ublas::matrix_column<M> mc1 (m1, 1), mc2 (m1, 1);
+            test_with (mc1, mc2, m1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                          mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, m1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                          mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, m1);
+#endif
+        }
+    }
+
+    void operator () (int) const {
+#ifdef USE_ADAPTOR
+        {
+#ifdef USE_BANDED
+            V v1 (N), v2 (N);
+            M m1 (N, N, 1, 1);
+            ublas::banded_adaptor<M> bam1 (m1, 1, 1);
+            test_with (v1, v2, bam1);
+
+            ublas::matrix_row<ublas::banded_adaptor<M> > mr1 (bam1, 1), mr2 (bam1, 1);
+            test_with (mr1, mr2, bam1);
+
+            ublas::matrix_column<ublas::banded_adaptor<M> > mc1 (bam1, 1), mc2 (bam1, 1);
+            test_with (mc1, mc2, bam1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<ublas::banded_adaptor<M> > mvr1 (bam1, ublas::range (0, N), ublas::range (0, N)),
+                                                                  mvr2 (bam1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, bam1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<ublas::banded_adaptor<M> > mvs1 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                                  mvs2 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, bam1);
+#endif
+#endif
+#ifdef USE_DIAGONAL
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            ublas::diagonal_adaptor<M> dam1 (m1);
+            test_with (v1, v2, dam1);
+
+            ublas::matrix_row<ublas::diagonal_adaptor<M> > mr1 (dam1, 1), mr2 (dam1, 1);
+            test_with (mr1, mr2, dam1);
+
+            ublas::matrix_column<ublas::diagonal_adaptor<M> > mc1 (dam1, 1), mc2 (dam1, 1);
+            test_with (mc1, mc2, dam1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<ublas::diagonal_adaptor<M> > mvr1 (dam1, ublas::range (0, N), ublas::range (0, N)),
+                                                                    mvr2 (dam1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, dam1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<ublas::diagonal_adaptor<M> > mvs1 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                                    mvs2 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, dam1);
+#endif
+#endif
+        }
+#endif
+    }
+};
+
+// Test matrix & vector
+void test_matrix_vector () {
+    std::cout << "test_matrix_vector" << std::endl;
+
+#ifdef USE_BANDED
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_DIAGONAL
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test43.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test43.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,326 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test4.hpp"
+
+// Test matrix expression templates
+template<class M, int N>
+struct test_my_matrix {
+    typedef typename M::value_type value_type;
+
+    template<class MP>
+    void test_with (MP &m1, MP &m2, MP &m3) const {
+        {
+            value_type t;
+
+            // Default Construct
+            default_construct<MP>::test ();
+            
+            // Copy and swap
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m1 = m2;
+            std::cout << "m1 = m2 = " << m1 << std::endl;
+            m1.assign_temporary (m2);
+            std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
+            m1.swap (m2);
+            std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
+
+            // Zero assignment
+            m1 = ublas::zero_matrix<> (m1.size1 (), m1.size2 ());
+            std::cout << "m1.zero_matrix = " << m1 << std::endl;
+            m1 = m2;
+
+            // Unary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            m2 = - m1;
+            std::cout << "- m1 = " << m2 << std::endl;
+            m2 = ublas::conj (m1);
+            std::cout << "conj (m1) = " << m2 << std::endl;
+
+            // Binary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = m1 + m2;
+            std::cout << "m1 + m2 = " << m3 << std::endl;
+            m3 = m1 - m2;
+            std::cout << "m1 - m2 = " << m3 << std::endl;
+
+            // Scaling a matrix
+            t = N;
+            initialize_matrix (m1);
+            m2 = value_type (1.) * m1;
+            std::cout << "1. * m1 = " << m2 << std::endl;
+            m2 = t * m1;
+            std::cout << "N * m1 = " << m2 << std::endl;
+            initialize_matrix (m1);
+            m2 = m1 * value_type (1.);
+            std::cout << "m1 * 1. = " << m2 << std::endl;
+            m2 = m1 * t;
+            std::cout << "m1 * N = " << m2 << std::endl;
+
+            // Some assignments
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m2 += m1;
+            std::cout << "m2 += m1 = " << m2 << std::endl;
+            m2 -= m1;
+            std::cout << "m2 -= m1 = " << m2 << std::endl;
+            m2 = m2 + m1;
+            std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
+            m2 = m2 - m1;
+            std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
+            m1 *= value_type (1.);
+            std::cout << "m1 *= 1. = " << m1 << std::endl;
+            m1 *= t;
+            std::cout << "m1 *= N = " << m1 << std::endl;
+
+            // Transpose
+            initialize_matrix (m1);
+            m2 = ublas::trans (m1);
+            std::cout << "trans (m1) = " << m2 << std::endl;
+
+            // Hermitean
+            initialize_matrix (m1);
+            m2 = ublas::herm (m1);
+            std::cout << "herm (m1) = " << m2 << std::endl;
+
+            // Matrix multiplication
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            // Banded times banded isn't banded
+            std::cout << "prod (m1, m2) = " << ublas::prod (m1, m2) << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+#ifdef USE_BANDED
+            M m1 (N, N, 1, 1), m2 (N, N, 1, 1), m3 (N, N, 1, 1);
+#endif
+#ifdef USE_DIAGONAL
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+#endif
+            test_with (m1, m2, m3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                   mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
+                                   mr3 (m3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+
+#ifdef USE_ADAPTOR
+        {
+#ifdef USE_BANDED
+            M m1 (N, N, 1, 1), m2 (N, N, 1, 1), m3 (N, N, 1, 1);
+            ublas::banded_adaptor<M> bam1 (m1, 1, 1), bam2 (m2, 1, 1), bam3 (m3, 1, 1);
+            test_with (bam1, bam2, bam3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<ublas::banded_adaptor<M> > mr1 (bam1, ublas::range (0, N), ublas::range (0, N)),
+                                                           mr2 (bam2, ublas::range (0, N), ublas::range (0, N)),
+                                                           mr3 (bam3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<ublas::banded_adaptor<M> > ms1 (bam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                           ms2 (bam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                           ms3 (bam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+#endif
+#ifdef USE_DIAGONAL
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+            ublas::diagonal_adaptor<M> dam1 (m1), dam2 (m2), dam3 (m3);
+            test_with (dam1, dam2, dam3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<ublas::diagonal_adaptor<M> > mr1 (dam1, ublas::range (0, N), ublas::range (0, N)),
+                                                             mr2 (dam2, ublas::range (0, N), ublas::range (0, N)),
+                                                             mr3 (dam3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<ublas::diagonal_adaptor<M> > ms1 (dam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                             ms2 (dam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                             ms3 (dam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+#endif
+        }
+#endif
+
+    }
+};
+
+// Test matrix
+void test_matrix () {
+    std::cout << "test_matrix" << std::endl;
+
+#ifdef USE_BANDED
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::banded_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix<ublas::banded_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix<ublas::banded_matrix<double, ublas::row_major, std::vector<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix<ublas::banded_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix<ublas::banded_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+
+#ifdef USE_DIAGONAL
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<double, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<mp_test_type, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<double, ublas::row_major, ublas::unbounded_array<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<std::complex<double>, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<mp_test_type, ublas::row_major, std::vector<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<double, ublas::row_major, std::vector<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<std::complex<mp_test_type>, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix<ublas::diagonal_matrix<std::complex<double>, ublas::row_major, std::vector<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,19 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test5.hpp"
+
+int main () {
+    test_matrix_vector ();
+    test_matrix ();
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test5.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,35 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST5_H
+#define TEST5_H
+
+#include <iostream>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/matrix_proxy.hpp>
+#include <boost/numeric/ublas/triangular.hpp>
+#include <boost/numeric/ublas/io.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+void test_matrix_vector ();
+void test_matrix ();
+
+
+// FIXME slice are failing in assignment to zero elements
+#undef USE_SLICE
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test52.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test52.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,214 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test5.hpp"
+
+// Test matrix & vector expression templates
+template<class V, class M, int N>
+struct test_my_matrix_vector {
+    typedef typename V::value_type value_type;
+
+    template<class VP, class MP>
+    void test_with (VP &v1, VP &v2, MP &m1) const {
+        {
+            // Rows and columns
+            initialize_matrix (m1);
+            for (int i = 0; i < N; ++ i) {
+                v2 = ublas::row (m1, i);
+                std::cout << "row (m, " << i << ") = " << v2 << std::endl;
+                v2 = ublas::column (m1, i);
+                std::cout << "column (m, " << i << ") = " << v2 << std::endl;
+            }
+
+            // Outer product
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v1 (0) = 0;
+            v2 (N - 1) = 0;
+            m1 = ublas::outer_prod (v1, v2);
+            std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
+
+            // Matrix vector product
+            initialize_matrix (m1);
+            initialize_vector (v1);
+            v2 = ublas::prod (m1, v1);
+            std::cout << "prod (m1, v1) = " << v2 << std::endl;
+            v2 = ublas::prod (v1, m1);
+            std::cout << "prod (v1, m1) = " << v2 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            test_with (v1, v2, m1);
+
+            ublas::matrix_row<M> mr1 (m1, N - 1), mr2 (m1, N - 1);
+            test_with (mr1, mr2, m1);
+
+            ublas::matrix_column<M> mc1 (m1, 0), mc2 (m1, 0);
+            test_with (mc1, mc2, m1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                          mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, m1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                          mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, m1);
+#endif
+        }
+    }
+
+    void operator () (int) const {
+#ifdef USE_ADAPTOR
+        {
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            ublas::triangular_adaptor<M> tam1 (m1);
+            test_with (v1, v2, tam1);
+
+            ublas::matrix_row<ublas::triangular_adaptor<M> > mr1 (tam1, N - 1), mr2 (tam1, N - 1);
+            test_with (mr1, mr2, tam1);
+
+            ublas::matrix_column<ublas::triangular_adaptor<M> > mc1 (tam1, 0), mc2 (tam1, 0);
+            test_with (mc1, mc2, tam1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<ublas::triangular_adaptor<M> > mvr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
+                                                                      mvr2 (tam1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, tam1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<ublas::triangular_adaptor<M> > mvs1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                                      mvs2 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, tam1);
+#endif
+        }
+#endif
+    }
+};
+
+// Test matrix & vector
+void test_matrix_vector () {
+    std::cout << "test_matrix_vector" << std::endl;
+
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::triangular_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::triangular_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () (0);
+
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test53.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test53.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,223 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test5.hpp"
+
+// Test matrix expression templates
+template<class M, int N>
+struct test_my_matrix {
+    typedef typename M::value_type value_type;
+
+    template<class MP>
+    void test_with (MP &m1, MP &m2, MP &m3) const {
+        {
+            value_type t;
+
+            // Default Construct
+            default_construct<MP>::test ();
+            
+            // Copy and swap
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m1 = m2;
+            std::cout << "m1 = m2 = " << m1 << std::endl;
+            m1.assign_temporary (m2);
+            std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
+            m1.swap (m2);
+            std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
+
+            // Zero assignment
+            m1 = ublas::zero_matrix<> (m1.size1 (), m1.size2 ());
+            std::cout << "m1.zero_matrix = " << m1 << std::endl;
+            m1 = m2;
+
+            // Unary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            m2 = - m1;
+            std::cout << "- m1 = " << m2 << std::endl;
+            m2 = ublas::conj (m1);
+            std::cout << "conj (m1) = " << m2 << std::endl;
+
+            // Binary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = m1 + m2;
+            std::cout << "m1 + m2 = " << m3 << std::endl;
+            m3 = m1 - m2;
+            std::cout << "m1 - m2 = " << m3 << std::endl;
+
+            // Scaling a matrix
+            t = N;
+            initialize_matrix (m1);
+            m2 = value_type (1.) * m1;
+            std::cout << "1. * m1 = " << m2 << std::endl;
+            m2 = t * m1;
+            std::cout << "N * m1 = " << m2 << std::endl;
+            initialize_matrix (m1);
+            m2 = m1 * value_type (1.);
+            std::cout << "m1 * 1. = " << m2 << std::endl;
+            m2 = m1 * t;
+            std::cout << "m1 * N = " << m2 << std::endl;
+
+            // Some assignments
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m2 += m1;
+            std::cout << "m2 += m1 = " << m2 << std::endl;
+            m2 -= m1;
+            std::cout << "m2 -= m1 = " << m2 << std::endl;
+            m2 = m2 + m1;
+            std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
+            m2 = m2 - m1;
+            std::cout << "m2 = m2 - m1 = " << m2 << std::endl;
+            m1 *= value_type (1.);
+            std::cout << "m1 *= 1. = " << m1 << std::endl;
+            m1 *= t;
+            std::cout << "m1 *= N = " << m1 << std::endl;
+
+            // Transpose
+            initialize_matrix (m1);
+            // Transpose of a triangular isn't triangular of the same kind
+            std::cout << "trans (m1) = " << ublas::trans (m1) << std::endl;
+
+            // Hermitian
+            initialize_matrix (m1);
+            // Hermitian of a triangular isn't hermitian of the same kind
+            std::cout << "herm (m1) = " << ublas::herm (m1) << std::endl;
+
+            // Matrix multiplication
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = ublas::prod (m1, m2);
+            std::cout << "prod (m1, m2) = " << m3 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+            test_with (m1, m2, m3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                   mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
+                                   mr3 (m3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+
+#ifdef USE_ADAPTOR
+        {
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+            ublas::triangular_adaptor<M> tam1 (m1), tam2 (m2), tam3 (m3);
+            test_with (tam1, tam2, tam3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<ublas::triangular_adaptor<M> > mr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
+                                                               mr2 (tam2, ublas::range (0, N), ublas::range (0, N)),
+                                                               mr3 (tam3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<ublas::triangular_adaptor<M> > ms1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                               ms2 (tam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                               ms3 (tam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+#endif
+    }
+};
+
+// Test matrix
+void test_matrix () {
+    std::cout << "test_matrix" << std::endl;
+
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix<ublas::triangular_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test6.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test6.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,19 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test6.hpp"
+
+int main () {
+    test_matrix_vector ();
+    test_matrix ();
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test6.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test6.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,32 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST6_H
+#define TEST6_H
+
+#include <iostream>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/matrix_proxy.hpp>
+#include <boost/numeric/ublas/symmetric.hpp>
+#include <boost/numeric/ublas/io.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+void test_matrix_vector ();
+void test_matrix ();
+
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test62.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test62.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,218 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test6.hpp"
+
+// Test matrix & vector expression templates
+template<class V, class M, int N>
+struct test_my_matrix_vector {
+    typedef typename V::value_type value_type;
+
+    template<class VP, class MP>
+    void test_with (VP &v1, VP &v2, MP &m1) const {
+        {
+            // Rows and columns
+            initialize_matrix (m1);
+            for (int i = 0; i < N; ++ i) {
+                v2 = ublas::row (m1, i);
+                std::cout << "row (m, " << i << ") = " << v2 << std::endl;
+                v2 = ublas::column (m1, i);
+                std::cout << "column (m, " << i << ") = " << v2 << std::endl;
+            }
+
+            // Outer product
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v1 (0) = 0;
+            v1 (N - 1) = 0;
+            v2 (0) = 0;
+            v2 (N - 1) = 0;
+            m1 = ublas::outer_prod (v1, v2);
+            std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
+
+            // Matrix vector product
+            initialize_matrix (m1);
+            initialize_vector (v1);
+            v2 = ublas::prod (m1, v1);
+            std::cout << "prod (m1, v1) = " << v2 << std::endl;
+            v2 = ublas::prod (v1, m1);
+            std::cout << "prod (v1, m1) = " << v2 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            test_with (v1, v2, m1);
+
+            ublas::matrix_row<M> mr1 (m1, N - 1), mr2 (m1, N - 1);
+            test_with (mr1, mr2, m1);
+
+            ublas::matrix_column<M> mc1 (m1, 0), mc2 (m1, 0);
+            test_with (mc1, mc2, m1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                          mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, m1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                          mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, m1);
+#endif
+        }
+    }
+
+    void operator () (int) const {
+#ifdef USE_ADAPTOR
+        {
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            ublas::symmetric_adaptor<M> tam1 (m1);
+            test_with (v1, v2, tam1);
+
+            ublas::matrix_row<ublas::symmetric_adaptor<M> > mr1 (tam1, N - 1), mr2 (tam1, N - 1);
+            test_with (mr1, mr2, tam1);
+
+            ublas::matrix_column<ublas::symmetric_adaptor<M> > mc1 (tam1, 0), mc2 (tam1, 0);
+            test_with (mc1, mc2, tam1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<ublas::symmetric_adaptor<M> > mvr1 (tam1, ublas::range (0, N), ublas::range (0, N)),
+                                                                     mvr2 (tam1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, tam1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<ublas::symmetric_adaptor<M> > mvs1 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                                     mvs2 (tam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, tam1);
+#endif
+        }
+#endif
+    }
+};
+
+// Test matrix & vector
+void test_matrix_vector () {
+    std::cout << "test_matrix_vector" << std::endl;
+
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::bounded_array<mp_test_type, 3> >,
+                          ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::bounded_array<double, 3> >,
+                          ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::bounded_array<std::complex<mp_test_type>, 3> >,
+                          ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::bounded_array<std::complex<double>, 3> >,
+                          ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, ublas::unbounded_array<mp_test_type> >,
+                          ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, ublas::unbounded_array<double> >,
+                          ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, ublas::unbounded_array<std::complex<mp_test_type> > >,
+                          ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, ublas::unbounded_array<std::complex<double> > >,
+                          ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<mp_test_type, std::vector<mp_test_type> >,
+                          ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3> () ();
+    test_my_matrix_vector<ublas::vector<double, std::vector<double> >,
+                          ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3> () (0);
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<mp_test_type>, std::vector<std::complex<mp_test_type> > >,
+                          ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3> () (0);
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3> () ();
+    test_my_matrix_vector<ublas::vector<std::complex<double>, std::vector<std::complex<double> > >,
+                          ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3> () (0);
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test63.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test63.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,223 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test6.hpp"
+
+// Test matrix expression templates
+template<class M, int N>
+struct test_my_matrix {
+    typedef typename M::value_type value_type;
+
+    template<class MP>
+    void test_with (MP &m1, MP &m2, MP &m3) const {
+        {
+            value_type t;
+
+            // Default Construct
+            default_construct<MP>::test ();
+            
+            // Copy and swap
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m1 = m2;
+            std::cout << "m1 = m2 = " << m1 << std::endl;
+            m1.assign_temporary (m2);
+            std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
+            m1.swap (m2);
+            std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
+
+            // Zero assignment
+            m1 = ublas::zero_matrix<> (m1.size1 (), m1.size2 ());
+            std::cout << "m1.zero_matrix = " << m1 << std::endl;
+            m1 = m2;
+
+            // Unary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            m2 = - m1;
+            std::cout << "- m1 = " << m2 << std::endl;
+            m2 = ublas::conj (m1);
+            std::cout << "conj (m1) = " << m2 << std::endl;
+
+            // Binary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = m1 + m2;
+            std::cout << "m1 + m2 = " << m3 << std::endl;
+            m3 = m1 - m2;
+            std::cout << "m1 - m2 = " << m3 << std::endl;
+
+            // Scaling a matrix
+            t = N;
+            initialize_matrix (m1);
+            m2 = value_type (1.) * m1;
+            std::cout << "1. * m1 = " << m2 << std::endl;
+            m2 = t * m1;
+            std::cout << "N * m1 = " << m2 << std::endl;
+            initialize_matrix (m1);
+            m2 = m1 * value_type (1.);
+            std::cout << "m1 * 1. = " << m2 << std::endl;
+            m2 = m1 * t;
+            std::cout << "m1 * N = " << m2 << std::endl;
+
+            // Some assignments
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m2 += m1;
+            std::cout << "m2 += m1 = " << m2 << std::endl;
+            m2 -= m1;
+            std::cout << "m2 -= m1 = " << m2 << std::endl;
+            m2 = m2 + m1;
+            std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
+            m2 = m2 - m1;
+            std::cout << "m2 = m1 - m1 = " << m2 << std::endl;
+            m1 *= value_type (1.);
+            std::cout << "m1 *= 1. = " << m1 << std::endl;
+            m1 *= t;
+            std::cout << "m1 *= N = " << m1 << std::endl;
+
+            // Transpose
+            initialize_matrix (m1);
+            m2 = ublas::trans (m1);
+            std::cout << "trans (m1) = " << m2 << std::endl;
+
+            // Hermitean
+            initialize_matrix (m1);
+            m2 = ublas::herm (m1);
+            std::cout << "herm (m1) = " << m2 << std::endl;
+
+            // Matrix multiplication
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = ublas::prod (m1, m2);
+            std::cout << "prod (m1, m2) = " << m3 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+            test_with (m1, m2, m3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                   mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
+                                   mr3 (m3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+
+#ifdef USE_ADAPTOR
+        {
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+            ublas::symmetric_adaptor<M> sam1 (m1), sam2 (m2), sam3 (m3);
+            test_with (sam1, sam2, sam3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<ublas::symmetric_adaptor<M> > mr1 (sam1, ublas::range (0, N), ublas::range (0, N)),
+                                                              mr2 (sam2, ublas::range (0, N), ublas::range (0, N)),
+                                                              mr3 (sam3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<ublas::symmetric_adaptor<M> > ms1 (sam1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                              ms2 (sam2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                                              ms3 (sam3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+#endif
+    }
+};
+
+// Test matrix
+void test_matrix () {
+    std::cout << "test_matrix" << std::endl;
+
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, bounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::bounded_array<mp_test_type, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, bounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<mp_test_type>, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, bounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::bounded_array<std::complex<double>, 3 * 3> >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, unbounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, ublas::unbounded_array<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, unbounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::unbounded_array<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, ublas::unbounded_array<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "mp_test_type, std::vector" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<mp_test_type, ublas::lower, ublas::row_major, std::vector<mp_test_type> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "double, std::vector" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, std::vector<double> >, 3 > () ();
+#endif
+
+#ifdef USE_STD_COMPLEX
+#ifdef USE_FLOAT
+    std::cout << "std::complex<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<std::complex<mp_test_type>, ublas::lower, ublas::row_major, std::vector<std::complex<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "std::complex<double>, std::vector" << std::endl;
+    test_my_matrix<ublas::symmetric_matrix<std::complex<double>, ublas::lower, ublas::row_major, std::vector<std::complex<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,31 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include <iostream>
+
+#include <boost/numeric/interval.hpp>
+#include <boost/numeric/interval/io.hpp>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/io.hpp>
+
+#include "test7.hpp"
+
+// this testcase requires fix of task #2473 
+
+int main () {
+    test_vector ();
+    test_matrix_vector ();
+    test_matrix ();
+    return 0;
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test7.hpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,36 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef TEST7_H
+#define TEST7_H
+
+#include <iostream>
+
+#include <boost/numeric/interval.hpp>
+#include <boost/numeric/interval/io.hpp>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/vector_proxy.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/matrix_proxy.hpp>
+#include <boost/numeric/ublas/io.hpp>
+
+namespace ublas = boost::numeric::ublas;
+
+#include "common/init.hpp"
+
+void test_vector ();
+void test_matrix_vector ();
+void test_matrix ();
+
+
+#endif

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test71.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test71.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,170 @@
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test7.hpp"
+
+// Test vector expression templates
+template<class V, int N>
+struct test_my_vector {
+    typedef typename V::value_type value_type;
+    typedef typename V::size_type size_type;
+    typedef typename ublas::type_traits<value_type>::real_type real_type;
+
+    template<class VP>
+    void test_with (VP &v1, VP &v2, VP &v3) const {
+        {
+            value_type t;
+            size_type i;
+            real_type n;
+
+            // Copy and swap
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v1 = v2;
+            std::cout << "v1 = v2 = " << v1 << std::endl;
+            v1.assign_temporary (v2);
+            std::cout << "v1.assign_temporary (v2) = " << v1 << std::endl;
+            v1.swap (v2);
+            std::cout << "v1.swap (v2) = " << v1 << " " << v2 << std::endl;
+
+            // Zero assignment
+            v1 = ublas::zero_vector<value_type> (v1.size ());
+            std::cout << "v1.zero_vector = " << v1 << std::endl;
+            v1 = v2;
+
+            // Unary vector operations resulting in a vector
+            initialize_vector (v1);
+            v2 = - v1;
+            std::cout << "- v1 = " << v2 << std::endl;
+            v2 = ublas::conj (v1);
+            std::cout << "conj (v1) = " << v2 << std::endl;
+
+            // Binary vector operations resulting in a vector
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v3 = v1 + v2;
+            std::cout << "v1 + v2 = " << v3 << std::endl;
+
+            v3 = v1 - v2;
+            std::cout << "v1 - v2 = " << v3 << std::endl;
+
+            // Scaling a vector
+            t = value_type (N);
+            initialize_vector (v1);
+            v2 = value_type (1.) * v1;
+            std::cout << "1. * v1 = " << v2 << std::endl;
+//            v2 = t * v1;
+            std::cout << "N * v1 = " << v2 << std::endl;
+            initialize_vector (v1);
+//            v2 = v1 * value_type (1.);
+            std::cout << "v1 * 1. = " << v2 << std::endl;
+//            v2 = v1 * t;
+            std::cout << "v1 * N = " << v2 << std::endl;
+
+            // Some assignments
+            initialize_vector (v1);
+            initialize_vector (v2);
+            v2 += v1;
+            std::cout << "v2 += v1 = " << v2 << std::endl;
+            v2 -= v1;
+            std::cout << "v2 -= v1 = " << v2 << std::endl;
+            v2 = v2 + v1;
+            std::cout << "v2 = v2 + v1 = " << v2 << std::endl;
+            v2 = v2 - v1;
+            std::cout << "v2 = v2 - v1 = " << v2 << std::endl;
+            v1 *= value_type (1.);
+            std::cout << "v1 *= 1. = " << v1 << std::endl;
+            v1 *= t;
+            std::cout << "v1 *= N = " << v1 << std::endl;
+
+            // Unary vector operations resulting in a scalar
+            initialize_vector (v1);
+            t = ublas::sum (v1);
+            std::cout << "sum (v1) = " << t << std::endl;
+            n = ublas::norm_1 (v1);
+            std::cout << "norm_1 (v1) = " << n << std::endl;
+            n = ublas::norm_2 (v1);
+            std::cout << "norm_2 (v1) = " << n << std::endl;
+            n = ublas::norm_inf (v1);
+            std::cout << "norm_inf (v1) = " << n << std::endl;
+
+            i = ublas::index_norm_inf (v1);
+            std::cout << "index_norm_inf (v1) = " << i << std::endl;
+
+            // Binary vector operations resulting in a scalar
+            initialize_vector (v1);
+            initialize_vector (v2);
+            t = ublas::inner_prod (v1, v2);
+            std::cout << "inner_prod (v1, v2) = " << t << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N), v2 (N), v3 (N);
+            test_with (v1, v2, v3);
+
+#ifdef USE_RANGE
+            ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
+                                   vr2 (v2, ublas::range (0, N)),
+                                   vr3 (v3, ublas::range (0, N));
+            test_with (vr1, vr2, vr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::vector_slice<V> vs1 (v1, ublas::slice (0, 1, N)),
+                                   vs2 (v2, ublas::slice (0, 1, N)),
+                                   vs3 (v3, ublas::slice (0, 1, N));
+            test_with (vs1, vs2, vs3);
+#endif
+        }
+    }
+};
+
+// Test vector
+void test_vector () {
+    std::cout << "test_vector" << std::endl;
+
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
+    test_my_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
+    test_my_vector<ublas::vector<boost::numeric::interval<double>, ublas::bounded_array<boost::numeric::interval<double>, 3> >, 3 > () ();
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
+    test_my_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
+    test_my_vector<ublas::vector<boost::numeric::interval<double>, ublas::unbounded_array<boost::numeric::interval<double> > >, 3 > () ();
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
+    test_my_vector<ublas::vector<boost::numeric::interval<mp_test_type>, std::vector<boost::numeric::interval<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
+    test_my_vector<ublas::vector<boost::numeric::interval<double>, std::vector<boost::numeric::interval<double> > >, 3 > () ();
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test72.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test72.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,165 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test7.hpp"
+
+// Test matrix & vector expression templates
+template<class V, class M, int N>
+struct test_my_matrix_vector {
+    typedef typename V::value_type value_type;
+
+    template<class VP, class MP>
+    void test_with (VP &v1, VP &v2, MP &m1) const {
+        {
+            // Rows and columns
+            initialize_matrix (m1);
+            for (int i = 0; i < N; ++ i) {
+                v1 = ublas::row (m1, i);
+                std::cout << "row (m, " << i << ") = " << v1 << std::endl;
+                v1 = ublas::column (m1, i);
+                std::cout << "column (m, " << i << ") = " << v1 << std::endl;
+            }
+
+            // Outer product
+            initialize_vector (v1);
+            initialize_vector (v2);
+            m1 = ublas::outer_prod (v1, v2);
+            std::cout << "outer_prod (v1, v2) = " << m1 << std::endl;
+
+            // Matrix vector product
+            initialize_matrix (m1);
+            initialize_vector (v1);
+            v2 = ublas::prod (m1, v1);
+            std::cout << "prod (m1, v1) = " << v2 << std::endl;
+            v2 = ublas::prod (v1, m1);
+            std::cout << "prod (v1, m1) = " << v2 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            V v1 (N), v2 (N);
+            M m1 (N, N);
+            test_with (v1, v2, m1);
+
+            ublas::matrix_row<M> mr1 (m1, 0), mr2 (m1, 1);
+            test_with (mr1, mr2, m1);
+
+            ublas::matrix_column<M> mc1 (m1, 0), mc2 (m1, 1);
+            test_with (mc1, mc2, m1);
+
+#ifdef USE_RANGE
+            ublas::matrix_vector_range<M> mvr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                          mvr2 (m1, ublas::range (0, N), ublas::range (0, N));
+            test_with (mvr1, mvr2, m1);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_vector_slice<M> mvs1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                          mvs2 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (mvs1, mvs2, m1);
+#endif
+        }
+    }
+};
+
+// Test matrix & vector
+void test_matrix_vector () {
+    std::cout << "test_matrix_vector" << std::endl;
+
+#ifdef USE_MATRIX
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3> >,
+                          ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3 * 3> >, 3> () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::bounded_array<boost::numeric::interval<double>, 3> >,
+                          ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<double>, 3 * 3> >, 3> () ();
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >,
+                          ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >, 3> () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::unbounded_array<boost::numeric::interval<double> > >,
+                          ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<double> > >, 3> () ();
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, std::vector<boost::numeric::interval<mp_test_type> > >,
+                          ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<boost::numeric::interval<mp_test_type> > >, 3> () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, std::vector<boost::numeric::interval<double> > >,
+                          ublas::matrix<boost::numeric::interval<double>, ublas::row_major, std::vector<boost::numeric::interval<double> > >, 3> () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_VECTOR_OF_VECTOR
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3> >,
+                          ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3>, 3 + 1> >, 3> () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::bounded_array<boost::numeric::interval<double>, 3> >,
+                          ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<double>, 3>, 3 + 1> >, 3> () ();
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >,
+                          ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<mp_test_type> > > >, 3> () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, ublas::unbounded_array<boost::numeric::interval<double> > >,
+                          ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<double> > > >, 3> () ();
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<mp_test_type>, std::vector<boost::numeric::interval<mp_test_type> > >,
+                          ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<mp_test_type> > > >, 3> () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
+    test_my_matrix_vector<ublas::vector<boost::numeric::interval<double>, std::vector<boost::numeric::interval<double> > >,
+                          ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<double> > > >, 3> () ();
+#endif
+#endif
+#endif
+}

Added: sandbox/big_number/libs/multiprecision/test/ublas_interop/test73.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/test/ublas_interop/test73.cpp	2012-08-07 04:10:07 EDT (Tue, 07 Aug 2012)
@@ -0,0 +1,202 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#include "test7.hpp"
+
+// Test matrix expression templates
+template<class M, int N>
+struct test_my_matrix {
+    typedef typename M::value_type value_type;
+
+    template<class MP>
+    void test_with (MP &m1, MP &m2, MP &m3) const {
+        {
+            value_type t;
+
+            // Copy and swap
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m1 = m2;
+            std::cout << "m1 = m2 = " << m1 << std::endl;
+            m1.assign_temporary (m2);
+            std::cout << "m1.assign_temporary (m2) = " << m1 << std::endl;
+            m1.swap (m2);
+            std::cout << "m1.swap (m2) = " << m1 << " " << m2 << std::endl;
+
+            // Zero assignment
+            m1 = ublas::zero_matrix<value_type> (m1.size1 (), m1.size2 ());
+            std::cout << "m1.zero_matrix = " << m1 << std::endl;
+            m1 = m2;
+
+            // Unary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            m2 = - m1;
+            std::cout << "- m1 = " << m2 << std::endl;
+            m2 = ublas::conj (m1);
+            std::cout << "conj (m1) = " << m2 << std::endl;
+
+            // Binary matrix operations resulting in a matrix
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = m1 + m2;
+            std::cout << "m1 + m2 = " << m3 << std::endl;
+            m3 = m1 - m2;
+            std::cout << "m1 - m2 = " << m3 << std::endl;
+
+            // Scaling a matrix
+            t = N;
+            initialize_matrix (m1);
+            m2 = value_type (1.) * m1;
+            std::cout << "1. * m1 = " << m2 << std::endl;
+            m2 = t * m1;
+            std::cout << "N * m1 = " << m2 << std::endl;
+            initialize_matrix (m1);
+            m2 = m1 * value_type (1.);
+            std::cout << "m1 * 1. = " << m2 << std::endl;
+            m2 = m1 * t;
+            std::cout << "m1 * N = " << m2 << std::endl;
+
+            // Some assignments
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m2 += m1;
+            std::cout << "m2 += m1 = " << m2 << std::endl;
+            m2 -= m1;
+            std::cout << "m2 -= m1 = " << m2 << std::endl;
+            m2 = m2 + m1;
+            std::cout << "m2 = m2 + m1 = " << m2 << std::endl;
+            m2 = m2 - m1;
+            std::cout << "m2 = m1 - m1 = " << m2 << std::endl;
+            m1 *= value_type (1.);
+            std::cout << "m1 *= 1. = " << m1 << std::endl;
+            m1 *= t;
+            std::cout << "m1 *= N = " << m1 << std::endl;
+
+            // Transpose
+            initialize_matrix (m1);
+            m2 = ublas::trans (m1);
+            std::cout << "trans (m1) = " << m2 << std::endl;
+
+            // Hermitean
+            initialize_matrix (m1);
+            m2 = ublas::herm (m1);
+            std::cout << "herm (m1) = " << m2 << std::endl;
+
+            // Matrix multiplication
+            initialize_matrix (m1);
+            initialize_matrix (m2);
+            m3 = ublas::prod (m1, m2);
+            std::cout << "prod (m1, m2) = " << m3 << std::endl;
+        }
+    }
+    void operator () () const {
+        {
+            M m1 (N, N), m2 (N, N), m3 (N, N);
+            test_with (m1, m2, m3);
+
+#ifdef USE_RANGE
+            ublas::matrix_range<M> mr1 (m1, ublas::range (0, N), ublas::range (0, N)),
+                                   mr2 (m2, ublas::range (0, N), ublas::range (0, N)),
+                                   mr3 (m3, ublas::range (0, N), ublas::range (0, N));
+            test_with (mr1, mr2, mr3);
+#endif
+
+#ifdef USE_SLICE
+            ublas::matrix_slice<M> ms1 (m1, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms2 (m2, ublas::slice (0, 1, N), ublas::slice (0, 1, N)),
+                                   ms3 (m3, ublas::slice (0, 1, N), ublas::slice (0, 1, N));
+            test_with (ms1, ms2, ms3);
+#endif
+        }
+    }
+};
+
+// Test matrix
+void test_matrix () {
+    std::cout << "test_matrix" << std::endl;
+
+#ifdef USE_MATRIX
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix<ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3 * 3> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
+    test_my_matrix<ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<boost::numeric::interval<double>, 3 * 3> >, 3 > () ();
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::matrix<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<boost::numeric::interval<double> > >, 3 > () ();
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix<ublas::matrix<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<boost::numeric::interval<mp_test_type> > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
+    test_my_matrix<ublas::matrix<boost::numeric::interval<double>, ublas::row_major, std::vector<boost::numeric::interval<double> > >, 3 > () ();
+#endif
+#endif
+#endif
+
+#ifdef USE_VECTOR_OF_VECTOR
+#ifdef USE_BOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, bounded_array" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<mp_test_type>, 3>, 3 + 1> >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, bounded_array" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::bounded_array<ublas::bounded_array<boost::numeric::interval<double>, 3>, 3 + 1> >, 3 > () ();
+#endif
+#endif
+
+#ifdef USE_UNBOUNDED_ARRAY
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<mp_test_type> > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, unbounded_array" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, ublas::unbounded_array<ublas::unbounded_array<boost::numeric::interval<double> > > >, 3 > () ();
+#endif
+#endif
+
+#ifdef USE_STD_VECTOR
+#ifdef USE_FLOAT
+    std::cout << "boost::numeric::interval<mp_test_type>, std::vector" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<mp_test_type>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<mp_test_type> > > >, 3 > () ();
+#endif
+
+#ifdef USE_DOUBLE
+    std::cout << "boost::numeric::interval<double>, std::vector" << std::endl;
+    test_my_matrix<ublas::vector_of_vector<boost::numeric::interval<double>, ublas::row_major, std::vector<std::vector<boost::numeric::interval<double> > > >, 3 > () ();
+#endif
+#endif
+#endif
+}