diff --git a/doc/traits.html b/doc/traits.html
index 5db668e3..cb127e41 100644
--- a/doc/traits.html
+++ b/doc/traits.html
@@ -471,6 +471,32 @@ and template parameters should be assigned according to the following table:
 <tr><td><code>IsWrapper</code></td><td><code></code>is the type a wrapper?</td><td><code>mpl::false_<br>mpl::true_</code></td><td><code>mpl::false_</code></td></tr>
 </table>
 
+
+<h3><a name="tracking">Bitwise serialization</a></h3>
+Some simple classes could be serialized just by directly copying all bits
+of the class. This is, in particular, the case for POD data types containing
+no pointer members, and which are neither versioned nor tracked. Some archives, 
+such as non-portable binary archives can make us of this information to 
+substantially speed up Serialization.
+
+To indicate the possibility of bitwise serialization the type trait defined 
+in the header
+file <a href="../../../boost/serialization/is_bitwise_serializable.hpp" target="is_bitwise_serializable">is_bitwise_serializable.hpp</a>
+is used:
+<pre><code>
+namespace boost { namespace serialization {
+    template<class T>
+    struct is_bitwise_serializable
+     : public is_arithmetic<T>
+    {};
+} }
+</code></pre>
+is used, and can be specialized for other classes. The specialization
+is made easy by the corresponding macro:
+<pre><code>
+BOOST_IS_BITWISE_SERIALIZABLE(my_class)
+</code></pre>
+
 <hr>
 <p><i>&copy; Copyright <a href="http://www.rrsd.com">Robert Ramey</a> 2002-2004 and Matthias Troyer 2006. 
 Distributed under the Boost Software License, Version 1.0. (See
diff --git a/include/boost/archive/basic_binary_iprimitive.hpp b/include/boost/archive/basic_binary_iprimitive.hpp
index 373cfa2a..dede7123 100644
--- a/include/boost/archive/basic_binary_iprimitive.hpp
+++ b/include/boost/archive/basic_binary_iprimitive.hpp
@@ -49,7 +49,7 @@ namespace std{
 #include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/mpl/placeholders.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/serialization/array.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
@@ -113,7 +113,12 @@ public:
     ~basic_binary_iprimitive();
 public:
     // we provide an optimized load for all fundamental types
-    typedef is_fundamental<mpl::_1> use_array_optimization;
+    //typedef serialization::is_bitwise_serializable<mpl::_1> 
+    //  use_array_optimization;
+    struct use_array_optimization {
+      template <class T>
+      struct apply : public serialization::is_bitwise_serializable<T> {};
+    };
 
     // the optimized load_array dispatches to load_binary 
     template <class ValueType>
@@ -160,7 +165,7 @@ basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
         static_cast<Elem *>(address), 
         s
     );
-    if(scount != static_cast<std::size_t>(s))
+    if(scount != static_cast<std::streamsize>(s))
         boost::throw_exception(
             archive_exception(archive_exception::stream_error)
         );
diff --git a/include/boost/archive/basic_binary_oprimitive.hpp b/include/boost/archive/basic_binary_oprimitive.hpp
index c961230b..43710e6f 100644
--- a/include/boost/archive/basic_binary_oprimitive.hpp
+++ b/include/boost/archive/basic_binary_oprimitive.hpp
@@ -46,7 +46,7 @@ namespace std{
 #include <boost/archive/basic_streambuf_locale_saver.hpp>
 #include <boost/archive/archive_exception.hpp>
 #include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/array.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@@ -113,8 +113,16 @@ public:
     BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 
     ~basic_binary_oprimitive();
 public:
+
     // we provide an optimized save for all fundamental types
-    typedef is_fundamental<mpl::_1> use_array_optimization;
+    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    //  use_array_optimization;
+    // workaround without using mpl lambdas
+    struct use_array_optimization {
+      template <class T>
+      struct apply : public serialization::is_bitwise_serializable<T> {};
+    };
+    
 
     // the optimized save_array dispatches to save_binary 
     template <class ValueType>
diff --git a/include/boost/serialization/complex.hpp b/include/boost/serialization/complex.hpp
new file mode 100644
index 00000000..bead218a
--- /dev/null
+++ b/include/boost/serialization/complex.hpp
@@ -0,0 +1,56 @@
+#ifndef  BOOST_SERIALIZATION_COMPLEX_HPP
+#define BOOST_SERIALIZATION_COMPLEX_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (C) Copyright 2007 Matthias Troyer . 
+// Use, modification and distribution is 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <complex>
+#include <boost/config.hpp>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    std::complex<T> & x,
+    const unsigned int /* file_version */
+){
+    ar & boost::serialization::make_nvp("real", x.real());
+    ar & boost::serialization::make_nvp("imag", x.imag());
+}
+
+/// specialization of serialization traits for complex
+template <class T>
+struct is_bitwise_serializable<std::complex<T> >
+ : public is_bitwise_serializable<T> {};
+
+template <class T>
+struct implementation_level<std::complex<T> >
+ : mpl::int_<object_serializable> {} ;
+
+// treat complex just like builtin arithmetic types for tracking
+template <class T>
+struct tracking_level<std::complex<T> >
+ : mpl::int_<track_never> {} ;
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_COMPLEX_HPP
diff --git a/include/boost/serialization/is_bitwise_serializable.hpp b/include/boost/serialization/is_bitwise_serializable.hpp
new file mode 100644
index 00000000..97d80b9a
--- /dev/null
+++ b/include/boost/serialization/is_bitwise_serializable.hpp
@@ -0,0 +1,46 @@
+// (C) Copyright 2007 Matthias Troyer
+
+// Use, modification and distribution is 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)
+
+//  Authors: Matthias Troyer
+
+/** @file is_bitwise_serializable.hpp
+ *
+ *  This header provides a traits class for determining whether a class
+ * can be serialized (in a non-portable way) just by copying the bits.
+ */
+
+
+#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_bitwise_serializable
+     : public is_arithmetic<T>
+    {};
+} // namespace serialization
+} // namespace boost
+
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_IS_BITWISE_SERIALIZABLE(T)              \
+namespace boost {                                     \
+namespace serialization {                             \
+template<>                                            \
+struct is_bitwise_serializable< T > : mpl::true_ {};  \
+}}                                                    \
+/**/
+
+#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
diff --git a/include/boost/serialization/utility.hpp b/include/boost/serialization/utility.hpp
index ea53d04d..56773932 100644
--- a/include/boost/serialization/utility.hpp
+++ b/include/boost/serialization/utility.hpp
@@ -22,6 +22,7 @@
 
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
 
 namespace boost { 
 namespace serialization {
@@ -41,6 +42,17 @@ inline void serialize(
     ar & boost::serialization::make_nvp("second", p.second);
 }
 
+/// specialization of is_bitwise_serializable for pairs
+template <class T, class U>
+struct is_bitwise_serializable<std::pair<T,U> >
+ : public mpl::and_<is_bitwise_serializable<T>,is_bitwise_serializable<U> >
+{
+};
+
+template <class T, class U>
+struct implementation_level<std::pair<T,U> >
+ : mpl::int_<object_serializable> {} ;
+
 } // serialization
 } // namespace boost
 
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 0e671355..f211e045 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -206,6 +206,7 @@ rule test-bsl-run_polymorphic_archive ( test-name : sources * ) {
 test-suite "serialization" :
      [ test-bsl-run_files test_array ]
      [ test-bsl-run_files test_binary ]
+     [ test-bsl-run_files test_complex ]
      [ test-bsl-run_files test_contained_class ]
      [ test-bsl-run_files test_cyclic_ptrs ]
      [ test-bsl-run_files test_delete_pointer ]
diff --git a/test/test_complex.cpp b/test/test_complex.cpp
new file mode 100644
index 00000000..a01867bd
--- /dev/null
+++ b/test/test_complex.cpp
@@ -0,0 +1,57 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_complex.cpp
+
+// (C) Copyright 2005 Matthias Troyer . 
+// Use, modification and distribution is 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)
+
+// should pass compilation and execution
+
+#include <fstream>
+
+#include <cstdio> // remove
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::remove;
+}
+#endif
+
+#include "test_tools.hpp"
+#include <boost/preprocessor/stringize.hpp>
+#include BOOST_PP_STRINGIZE(BOOST_ARCHIVE_TEST)
+
+#include <boost/serialization/complex.hpp>
+
+int test_main( int /* argc */, char* /* argv */[] )
+{
+    const char * testfile = boost::archive::tmpnam(NULL);
+    BOOST_REQUIRE(NULL != testfile);
+
+    // test array of objects
+    std::complex<float> a(std::rand(),std::rand());
+    std::complex<double> b(std::rand(),std::rand());
+    {   
+        test_ostream os(testfile, TEST_STREAM_FLAGS);
+        test_oarchive oa(os);
+        oa << boost::serialization::make_nvp("afloatcomplex", a);
+        oa << boost::serialization::make_nvp("adoublecomplex", b);
+    }
+    std::complex<float> a1;
+    std::complex<double> b1;
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is);
+        ia >> boost::serialization::make_nvp("afloatcomplex", a1);
+        ia >> boost::serialization::make_nvp("adoublecomplex", b1);
+    }
+    bool equal = (std::abs(a-a1) <= 2.*std::numeric_limits<float>::round_error()  
+          && std::abs(b-b1) <= 2.*std::numeric_limits<double>::round_error() );
+                  
+    BOOST_CHECK(equal);
+    std::remove(testfile);
+    return EXIT_SUCCESS;
+}
+
+// EOF