diff --git a/doc/concepts/state_wrapper.qbk b/doc/concepts/state_wrapper.qbk
index 768671db..9fbbfe8e 100644
--- a/doc/concepts/state_wrapper.qbk
+++ b/doc/concepts/state_wrapper.qbk
@@ -29,7 +29,7 @@ The `State Wrapper` concept describes the way odeint creates temporary state obj
 
 [table
   [[Name] [Expression] [Type] [Semantics]]
-  [[Get resizeability] [`is_resizeable< State >`] [`boost::false_type` or `boost::true_type`] [Returns `boost::true_type` if the `State` is resizeable, `boost::false_type` otherwise.]]
+  [[Get resizeability] [`is_resizeable< State >`] [`std::false_type` or `std::true_type`] [Returns `std::true_type` if the `State` is resizeable, `std::false_type` otherwise.]]
   [[Create `WrappedState` type] [`state_wrapper< State >`] [`WrappedState`] [Creates the type for a `WrappedState` for the state type `State`]]
   [[Constructor] [`WrappedState()`] [`WrappedState`] [Constructs a state wrapper with an empty state]]
   [[Copy Constructor] [`WrappedState( w )`] [`WrappedState`] [Constructs a state wrapper with a state of the same size as the state in `w`]]
diff --git a/doc/details_state_types_algebras_operations.qbk b/doc/details_state_types_algebras_operations.qbk
index 78481441..7a39e179 100644
--- a/doc/details_state_types_algebras_operations.qbk
+++ b/doc/details_state_types_algebras_operations.qbk
@@ -81,8 +81,8 @@ First, the state has to be tagged as resizeable by specializing the struct
 [table
   [[Name] [Expression] [Type] [Semantics]]
   [[Resizability] [`is_resizeable<State>::type`]
-    [`boost::true_type` or `boost::false_type`] 
-    [Determines resizeability of the state type, returns `boost::true_type` if
+    [`std::true_type` or `std::false_type`] 
+    [Determines resizeability of the state type, returns `std::true_type` if
     the state is resizeable.]]
   [[Resizability] [`is_resizeable<State>::value`]
     [`bool`] 
@@ -242,7 +242,7 @@ sized objects:
 template<>
 struct is_resizeable< gsl_vector* >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
diff --git a/examples/2d_lattice/vector_vector_resize.hpp b/examples/2d_lattice/vector_vector_resize.hpp
index 7132aa59..ca8021ac 100644
--- a/examples/2d_lattice/vector_vector_resize.hpp
+++ b/examples/2d_lattice/vector_vector_resize.hpp
@@ -14,7 +14,7 @@
 #define VECTOR_VECTOR_RESIZE_HPP
 
 #include <vector>
-
+#include <type_traits>
 #include <boost/range.hpp>
 
 namespace boost { namespace numeric { namespace odeint {
@@ -22,7 +22,7 @@ namespace boost { namespace numeric { namespace odeint {
 template<>
 struct is_resizeable< std::vector< std::vector< double > > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
@@ -65,7 +65,7 @@ struct state_wrapper< std::vector< std::vector< double > > >
 {
     typedef std::vector< std::vector< double > > state_type;
     typedef state_wrapper< state_type > state_wrapper_type;
-    typedef boost::true_type is_resizeable;
+    typedef std::true_type is_resizeable;
 
     state_type m_v;
 
diff --git a/examples/list_lattice.cpp b/examples/list_lattice.cpp
index 2c716ca1..10a7b98f 100644
--- a/examples/list_lattice.cpp
+++ b/examples/list_lattice.cpp
@@ -24,7 +24,7 @@ namespace boost { namespace numeric { namespace odeint {
 template< >
 struct is_resizeable< state_type >
 { // declare resizeability
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
diff --git a/examples/my_vector.cpp b/examples/my_vector.cpp
index 4d862227..d2c33498 100644
--- a/examples/my_vector.cpp
+++ b/examples/my_vector.cpp
@@ -75,7 +75,7 @@ namespace boost { namespace numeric { namespace odeint {
 template<size_t N>
 struct is_resizeable< my_vector<N> >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     static const bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp b/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp
index 3c5f2d46..0fcf348e 100644
--- a/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp
+++ b/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp
@@ -24,6 +24,8 @@
 
 #include <blaze/math/dense/DynamicVector.h>
 
+#include <type_traits>
+
 namespace boost {
 namespace numeric {
 namespace odeint {
@@ -31,7 +33,7 @@ namespace odeint {
 template< typename T , bool TF >
 struct is_resizeable< blaze::DynamicVector< T , TF > > 
 { 
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/external/compute/compute_resize.hpp b/include/boost/numeric/odeint/external/compute/compute_resize.hpp
index 013a7acc..e9f2f651 100644
--- a/include/boost/numeric/odeint/external/compute/compute_resize.hpp
+++ b/include/boost/numeric/odeint/external/compute/compute_resize.hpp
@@ -22,6 +22,8 @@
 
 #include <boost/numeric/odeint/util/copy.hpp>
 
+#include <type_traits>
+
 namespace boost {
 namespace numeric {
 namespace odeint {
@@ -29,7 +31,7 @@ namespace odeint {
 template< class T, class A >
 struct is_resizeable< boost::compute::vector< T , A > >
 {
-    struct type : public boost::true_type { };
+    struct type : public std::true_type { };
     const static bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp b/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
index 6295c03a..b92a6d1f 100644
--- a/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
+++ b/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
@@ -24,6 +24,7 @@ copy at http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/numeric/mtl/matrix/dense2D.hpp>
 #include <boost/numeric/mtl/matrix/compressed2D.hpp>
 
+#include <type_traits>
 
 namespace boost {
 namespace numeric {
@@ -33,21 +34,21 @@ namespace odeint {
 template< class Value , class Parameters >
 struct is_resizeable< mtl::dense_vector< Value , Parameters > >
 { 
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
 template< class Value , class Parameters >
 struct is_resizeable< mtl::dense2D< Value , Parameters > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
 template< class Value , class Parameters >
 struct is_resizeable< mtl::compressed2D< Value , Parameters > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp b/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp
index d9c2359c..50a99e5c 100644
--- a/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp
+++ b/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp
@@ -13,12 +13,14 @@
 
 #include <boost/numeric/odeint/util/same_size.hpp>
 
+#include <type_traits>
+
 namespace boost { namespace numeric { namespace odeint {
 
 template<typename T, typename S>
 struct is_resizeable< nt2::container::table<T,S> >
 {
-  typedef boost::true_type type;
+  typedef std::true_type type;
   static const bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/external/openmp/openmp_state.hpp b/include/boost/numeric/odeint/external/openmp/openmp_state.hpp
index 83bbc192..8b35e804 100644
--- a/include/boost/numeric/odeint/external/openmp/openmp_state.hpp
+++ b/include/boost/numeric/odeint/external/openmp/openmp_state.hpp
@@ -22,6 +22,7 @@
 #include <omp.h>
 #include <vector>
 #include <algorithm>
+#include <type_traits>
 #include <boost/range/adaptor/sliced.hpp>
 #include <boost/numeric/odeint/util/copy.hpp>
 #include <boost/numeric/odeint/util/split.hpp>
@@ -56,7 +57,7 @@ struct openmp_state : public std::vector< std::vector< T > >
 
 
 template< class T >
-struct is_resizeable< openmp_state< T > > : boost::true_type { };
+struct is_resizeable< openmp_state< T > > : std::true_type { };
 
 
 template< class T >
diff --git a/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp b/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp
index 8a5e6060..6bb30758 100644
--- a/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp
+++ b/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp
@@ -18,6 +18,8 @@
 #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED
 #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED
 
+#include <type_traits>
+
 #include <boost/range.hpp>
 
 #include <thrust/device_vector.h>
@@ -38,7 +40,7 @@ namespace odeint {
 template< class T , class A >                               \
 struct is_resizeable< THRUST_VECTOR<T,A> >                  \
 {                                                           \
-    struct type : public boost::true_type { };              \
+    struct type : public std::true_type { };              \
     const static bool value = type::value;                  \
 };                                                          \
 
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
index 2d6291ed..e7bb90a8 100644
--- a/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
+++ b/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
@@ -19,6 +19,8 @@
 #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED
 #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED
 
+#include <type_traits>
+
 #include <vexcl/vector.hpp>
 #include <vexcl/multivector.hpp>
 
@@ -36,7 +38,7 @@ namespace odeint {
  * specializations for vex::vector< T >
  */
 template< typename T >
-struct is_resizeable< vex::vector< T > > : boost::true_type { };
+struct is_resizeable< vex::vector< T > > : std::true_type { };
 
 template< typename T >
 struct resize_impl< vex::vector< T > , vex::vector< T > >
@@ -64,7 +66,7 @@ struct same_size_impl< vex::vector< T > , vex::vector< T > >
  * specializations for vex::multivector< T >
  */
 template< typename T , size_t N >
-struct is_resizeable< vex::multivector< T , N > > : boost::true_type { };
+struct is_resizeable< vex::multivector< T , N > > : std::true_type { };
 
 template< typename T , size_t N >
 struct resize_impl< vex::multivector< T , N > , vex::multivector< T , N > >
diff --git a/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp b/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
index d3240705..5f814a91 100644
--- a/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
+++ b/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
@@ -19,6 +19,8 @@
 #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED
 #define BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED
 
+#include <type_traits>
+
 #include <viennacl/vector.hpp>
 
 #include <boost/numeric/odeint/util/is_resizeable.hpp>
@@ -35,7 +37,7 @@ namespace odeint {
  * specializations for viennacl::vector< T >
  */
 template< typename T >
-struct is_resizeable< viennacl::vector< T > > : boost::true_type { };
+struct is_resizeable< viennacl::vector< T > > : std::true_type { };
 
 template< typename T >
 struct resize_impl< viennacl::vector< T > , viennacl::vector< T > >
diff --git a/include/boost/numeric/odeint/util/is_resizeable.hpp b/include/boost/numeric/odeint/util/is_resizeable.hpp
index ad7332dc..e60564f5 100644
--- a/include/boost/numeric/odeint/util/is_resizeable.hpp
+++ b/include/boost/numeric/odeint/util/is_resizeable.hpp
@@ -20,6 +20,7 @@
 
 
 #include <vector>
+#include <type_traits>
 
 #include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/remove_reference.hpp>
@@ -40,7 +41,7 @@ namespace odeint {
  * by default any type is not resizable
  */
 template< typename Container , typename Enabler = void >
-struct is_resizeable_sfinae : boost::false_type {};
+struct is_resizeable_sfinae : std::false_type {};
 
 template< typename Container >
 struct is_resizeable : is_resizeable_sfinae< Container > {};
@@ -51,7 +52,7 @@ struct is_resizeable : is_resizeable_sfinae< Container > {};
  * specialization for std::vector
  */
 template< class V, class A >
-struct is_resizeable< std::vector< V , A  > > : boost::true_type {};
+struct is_resizeable< std::vector< V , A  > > : std::true_type {};
 
 
 /*
@@ -65,7 +66,7 @@ struct is_resizeable_sfinae<
     typedef typename boost::mpl::find_if< FusionSequence , is_resizeable< boost::mpl::_1 > >::type iter;
     typedef typename boost::mpl::end< FusionSequence >::type last;
 
-    typedef typename boost::mpl::if_< boost::is_same< iter , last > , boost::false_type , boost::true_type >::type type;
+    typedef typename boost::mpl::if_< boost::is_same< iter , last > , std::false_type , std::true_type >::type type;
     const static bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/util/multi_array_adaption.hpp b/include/boost/numeric/odeint/util/multi_array_adaption.hpp
index d7c3ccb9..8eaf26bd 100644
--- a/include/boost/numeric/odeint/util/multi_array_adaption.hpp
+++ b/include/boost/numeric/odeint/util/multi_array_adaption.hpp
@@ -28,6 +28,7 @@
 #include <boost/mpl/bool.hpp>
 #include <boost/multi_array.hpp>
 
+#include <type_traits>
 
 namespace boost {
 namespace numeric {
@@ -36,14 +37,14 @@ namespace odeint {
 template< typename T >
 struct is_multi_array
 {
-    typedef boost::false_type type;
+    typedef std::false_type type;
     const static bool value = type::value;
 };
     
 template< typename T >
 struct is_resizeable_multi_array
 {
-    typedef boost::false_type type;
+    typedef std::false_type type;
     const static bool value = type::value;
 };
 
@@ -52,14 +53,14 @@ struct is_resizeable_multi_array
 template< typename V , size_t Dim , typename A >
 struct is_multi_array< boost::multi_array< V , Dim , A > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
 template< typename V , size_t Dim , typename A >
 struct is_resizeable_multi_array< boost::multi_array< V , Dim , A > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
@@ -69,7 +70,7 @@ struct is_resizeable_multi_array< boost::multi_array< V , Dim , A > >
 template< typename T  >
 struct is_resizeable_sfinae< T , typename boost::enable_if< typename is_resizeable_multi_array< T >::type >::type >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
diff --git a/include/boost/numeric/odeint/util/resize.hpp b/include/boost/numeric/odeint/util/resize.hpp
index 3645782a..496aacca 100644
--- a/include/boost/numeric/odeint/util/resize.hpp
+++ b/include/boost/numeric/odeint/util/resize.hpp
@@ -19,6 +19,8 @@
 #ifndef BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED
 #define BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED
 
+#include <type_traits>
+
 #include <boost/range.hpp>
 
 #include <boost/utility/enable_if.hpp>
@@ -77,13 +79,13 @@ namespace detail {
         }
 
         template< class StateOut , class StateIn >
-        void resize_op( StateOut &x1 , const StateIn &x2 , boost::true_type ) const
+        void resize_op( StateOut &x1 , const StateIn &x2 , std::true_type ) const
         {
             resize( x1 , x2 );
         }
 
         template< class StateOut , class StateIn >
-        void resize_op( StateOut &/*x1*/ , const StateIn &/*x2*/ , boost::false_type ) const
+        void resize_op( StateOut &/*x1*/ , const StateIn &/*x2*/ , std::false_type ) const
         {
         }
 
diff --git a/include/boost/numeric/odeint/util/resizer.hpp b/include/boost/numeric/odeint/util/resizer.hpp
index cd27990b..965966b0 100644
--- a/include/boost/numeric/odeint/util/resizer.hpp
+++ b/include/boost/numeric/odeint/util/resizer.hpp
@@ -22,13 +22,14 @@
 #include <boost/numeric/odeint/util/is_resizeable.hpp>
 #include <boost/numeric/odeint/util/same_size.hpp>
 #include <boost/numeric/odeint/util/resize.hpp>
+#include <type_traits>
 
 namespace boost {
 namespace numeric {
 namespace odeint {
 
 template< class ResizeWrappedState , class State >
-bool adjust_size_by_resizeability( ResizeWrappedState &x , const State &y , boost::true_type )
+bool adjust_size_by_resizeability( ResizeWrappedState &x , const State &y , std::true_type )
 {
     if ( !same_size( x.m_v , y ) )
     {
@@ -40,7 +41,7 @@ bool adjust_size_by_resizeability( ResizeWrappedState &x , const State &y , boos
 }
 
 template< class ResizeWrappedState , class State >
-bool adjust_size_by_resizeability( ResizeWrappedState & /* x */ , const State & /* y */ , boost::false_type )
+bool adjust_size_by_resizeability( ResizeWrappedState & /* x */ , const State & /* y */ , std::false_type )
 {
     return false;
 }
diff --git a/include/boost/numeric/odeint/util/same_size.hpp b/include/boost/numeric/odeint/util/same_size.hpp
index 81ae249d..c7f5b71b 100644
--- a/include/boost/numeric/odeint/util/same_size.hpp
+++ b/include/boost/numeric/odeint/util/same_size.hpp
@@ -19,6 +19,8 @@
 #ifndef BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED
 #define BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED
 
+#include <type_traits>
+
 #include <boost/numeric/odeint/util/is_resizeable.hpp>
 
 #include <boost/utility/enable_if.hpp>
@@ -77,13 +79,13 @@ struct same_size_fusion
     }
 
     template< class S1 , class S2 >
-    bool same_size_op( const S1 &x1 , const S2 &x2 , boost::true_type ) const
+    bool same_size_op( const S1 &x1 , const S2 &x2 , std::true_type ) const
     {
         return same_size( x1 , x2 );
     }
 
     template< class S1 , class S2 >
-    bool same_size_op( const S1 &/*x1*/ , const S2 &/*x2*/ , boost::false_type ) const
+    bool same_size_op( const S1 &/*x1*/ , const S2 &/*x2*/ , std::false_type ) const
     {
         return true;
     }
diff --git a/include/boost/numeric/odeint/util/ublas_wrapper.hpp b/include/boost/numeric/odeint/util/ublas_wrapper.hpp
index c8facfc4..dde16ccd 100644
--- a/include/boost/numeric/odeint/util/ublas_wrapper.hpp
+++ b/include/boost/numeric/odeint/util/ublas_wrapper.hpp
@@ -18,8 +18,8 @@
 #ifndef BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED
 #define BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED
 
+#include <type_traits>
 
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/numeric/ublas/vector.hpp>
 #include <boost/numeric/ublas/matrix.hpp>
 #include <boost/numeric/ublas/lu.hpp>
@@ -171,7 +171,7 @@ namespace odeint {
 template< class T , class A >
 struct is_resizeable< boost::numeric::ublas::vector< T , A > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
@@ -182,7 +182,7 @@ struct is_resizeable< boost::numeric::ublas::vector< T , A > >
 template< class T , class L , class A >
 struct is_resizeable< boost::numeric::ublas::matrix< T , L , A > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
@@ -193,7 +193,7 @@ struct is_resizeable< boost::numeric::ublas::matrix< T , L , A > >
 template< class T , class A >
 struct is_resizeable< boost::numeric::ublas::permutation_matrix< T , A > >
 {
-    typedef boost::true_type type;
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 
diff --git a/test/diagnostic_state_type.hpp b/test/diagnostic_state_type.hpp
index 13008caa..759ef0d6 100644
--- a/test/diagnostic_state_type.hpp
+++ b/test/diagnostic_state_type.hpp
@@ -19,6 +19,8 @@
 #define LIBS_NUMERIC_ODEINT_TEST_DIAGNOSTIC_STATE_TYPE_HPP_DEFINED
 
 #include <array>
+#include <type_traits>
+
 #include <boost/numeric/odeint/util/is_resizeable.hpp>
 #include <boost/numeric/odeint/util/same_size.hpp>
 #include <boost/numeric/odeint/util/resize.hpp>
@@ -84,7 +86,7 @@ namespace odeint {
     template< size_t N >
     struct is_resizeable< diagnostic_type< N > >
     {
-        typedef boost::true_type type;
+        typedef std::true_type type;
         const static bool value = type::value;
     };
 
diff --git a/test/euler_stepper.cpp b/test/euler_stepper.cpp
index a274de4b..6d27167a 100644
--- a/test/euler_stepper.cpp
+++ b/test/euler_stepper.cpp
@@ -22,6 +22,7 @@
 #include <utility>
 #include <iostream>
 #include <vector>
+#include <type_traits>
 
 #include <boost/numeric/odeint/stepper/euler.hpp>
 #include <boost/numeric/odeint/algebra/range_algebra.hpp>
@@ -55,8 +56,8 @@ namespace odeint {
 template<>
 struct is_resizeable< my_vec >
 {
-    //struct type : public boost::true_type { };
-    typedef boost::true_type type;
+    //struct type : public std::true_type { };
+    typedef std::true_type type;
     const static bool value = type::value;
 };
 } } }
diff --git a/test/is_resizeable.cpp b/test/is_resizeable.cpp
index cb8e9c1c..3ef00c92 100644
--- a/test/is_resizeable.cpp
+++ b/test/is_resizeable.cpp
@@ -23,6 +23,7 @@
 #define BOOST_TEST_MODULE odeint_is_resizeable
 
 #include <vector>
+#include <type_traits>
 #include <cmath>
 
 #include <boost/test/unit_test.hpp>
@@ -44,14 +45,14 @@ template< typename T > struct my_seq2 {};
 
 namespace boost { namespace fusion { namespace traits {
     
-    template< typename T > struct is_sequence< my_seq1< T > > : boost::true_type {};
-    template< typename T > struct is_sequence< my_seq2< T > > : boost::true_type {};
+    template< typename T > struct is_sequence< my_seq1< T > > : std::true_type {};
+    template< typename T > struct is_sequence< my_seq2< T > > : std::true_type {};
 } } } // boost::fusion::traits
 
 namespace boost { namespace numeric { namespace odeint {
     
     template< typename T >
-    struct is_resizeable< my_seq2< T > > : boost::true_type {};
+    struct is_resizeable< my_seq2< T > > : std::true_type {};
     
 } } } // boost::numeric::odeint
 
diff --git a/test/resizing_test_state_type.hpp b/test/resizing_test_state_type.hpp
index ffad1a10..e44c8cdd 100644
--- a/test/resizing_test_state_type.hpp
+++ b/test/resizing_test_state_type.hpp
@@ -23,7 +23,7 @@
 #include <boost/numeric/odeint/util/same_size.hpp>
 
 #include <array>
-
+#include <type_traits>
 
 
 // Mario: velocity verlet tests need arrays of size 2
@@ -39,7 +39,7 @@ namespace odeint {
     template<>
     struct is_resizeable< test_array_type >
     {
-        typedef boost::true_type type;
+        typedef std::true_type type;
         const static bool value = type::value;
     };