diff --git a/CMakeLists.txt b/CMakeLists.txt
index 301880e25..7d71a950a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,26 +12,53 @@ add_library(Boost::numeric_odeint ALIAS boost_numeric_odeint)
 
 target_include_directories(boost_numeric_odeint INTERFACE include)
 
-target_link_libraries(boost_numeric_odeint
-  INTERFACE
-    Boost::assert
-    Boost::compute
-    Boost::config
-    Boost::core
-    Boost::fusion
-    Boost::iterator
-    Boost::math
-    Boost::mpi
-    Boost::mpl
-    Boost::multi_array
-    Boost::numeric_ublas
-    Boost::preprocessor
-    Boost::range
-    Boost::throw_exception
-    Boost::type_traits
-    Boost::units
-    Boost::utility
-)
+if(BOOST_NUMERIC_ODEINT_NO_ADAPTORS)
+
+  target_link_libraries(boost_numeric_odeint
+    INTERFACE
+      Boost::assert
+      Boost::config
+      Boost::core
+      Boost::fusion
+      Boost::iterator
+      Boost::math
+      Boost::mpl
+      Boost::multi_array
+      Boost::numeric_ublas
+      Boost::preprocessor
+      Boost::range
+      Boost::static_assert
+      Boost::throw_exception
+      Boost::type_traits
+      Boost::units
+      Boost::utility
+  )
+
+else()
+
+  target_link_libraries(boost_numeric_odeint
+    INTERFACE
+      Boost::assert
+      Boost::compute
+      Boost::config
+      Boost::core
+      Boost::fusion
+      Boost::iterator
+      Boost::math
+      Boost::mpi
+      Boost::mpl
+      Boost::multi_array
+      Boost::numeric_ublas
+      Boost::preprocessor
+      Boost::range
+      Boost::static_assert
+      Boost::throw_exception
+      Boost::type_traits
+      Boost::units
+      Boost::utility
+  )
+
+endif()
 
 if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
 
diff --git a/doc/concepts/state_wrapper.qbk b/doc/concepts/state_wrapper.qbk
index 768671db5..9fbbfe8e3 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 784814417..7a39e179a 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 7132aa59d..ca8021acb 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/const_step_iterator.cpp b/examples/const_step_iterator.cpp
index fc393037e..34faef7fd 100644
--- a/examples/const_step_iterator.cpp
+++ b/examples/const_step_iterator.cpp
@@ -41,7 +41,7 @@ const double b = 8.0 / 3.0;
 struct lorenz
 {
     template< class State , class Deriv >
-    void operator()( const State &x , Deriv &dxdt , double t ) const
+    void operator()( const State &x , Deriv &dxdt , double ) const
     {
         dxdt[0] = sigma * ( x[1] - x[0] );
         dxdt[1] = R * x[0] - x[1] - x[0] * x[2];
@@ -51,7 +51,7 @@ struct lorenz
 
 
 
-int main( int argc , char **argv )
+int main()
 {
     typedef std::array< double , 3 > state_type;
 
diff --git a/examples/list_lattice.cpp b/examples/list_lattice.cpp
index 2c716ca11..10a7b98f1 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 4d8622272..d2c334986 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/examples/stuart_landau.cpp b/examples/stuart_landau.cpp
index da29b5e9c..d20a4e8d8 100644
--- a/examples/stuart_landau.cpp
+++ b/examples/stuart_landau.cpp
@@ -30,7 +30,7 @@ struct stuart_landau
     stuart_landau( double eta = 1.0 , double alpha = 1.0 )
     : m_eta( eta ) , m_alpha( alpha ) { }
 
-    void operator()( const state_type &x , state_type &dxdt , double t ) const
+    void operator()( const state_type &x , state_type &dxdt , double ) const
     {
         const complex< double > I( 0.0 , 1.0 );
         dxdt = ( 1.0 + m_eta * I ) * x - ( 1.0 + m_alpha * I ) * norm( x ) * x;
@@ -71,7 +71,7 @@ struct streaming_observer
 
 
 
-int main( int argc , char **argv )
+int main()
 {
     //[ stuart_landau_integration
     state_type x = complex< double >( 1.0 , 0.0 );
diff --git a/examples/two_dimensional_phase_lattice.cpp b/examples/two_dimensional_phase_lattice.cpp
index 1fe4b9554..64c271b8c 100644
--- a/examples/two_dimensional_phase_lattice.cpp
+++ b/examples/two_dimensional_phase_lattice.cpp
@@ -98,7 +98,7 @@ class write_snapshots
 
     write_snapshots( void ) : m_count( 0 ) { }
 
-    void operator()( const state_type &x , double t )
+    void operator()( const state_type &x , double )
     {
         map< size_t , string >::const_iterator it = m_snapshots.find( m_count );
         if( it != m_snapshots.end() )
@@ -126,7 +126,7 @@ class write_snapshots
 };
 
 
-int main( int argc , char **argv )
+int main()
 {
     size_t size1 = 128 , size2 = 128;
     state_type x( size1 , size2 , 0.0 );
diff --git a/examples/van_der_pol_stiff.cpp b/examples/van_der_pol_stiff.cpp
index a53ae4dbe..4fe9b63a2 100644
--- a/examples/van_der_pol_stiff.cpp
+++ b/examples/van_der_pol_stiff.cpp
@@ -33,7 +33,7 @@ typedef boost::numeric::ublas::matrix< double > matrix_type;
 
 struct vdp_stiff
 {
-    void operator()( const vector_type &x , vector_type &dxdt , double t )
+    void operator()( const vector_type &x , vector_type &dxdt , double )
     {
         dxdt[0] = x[1];
         dxdt[1] = -x[0] - mu * x[1] * (x[0]*x[0]-1.0);
@@ -42,7 +42,7 @@ struct vdp_stiff
 
 struct vdp_stiff_jacobi
 {
-    void operator()( const vector_type &x , matrix_type &J , const double &t , vector_type &dfdt )
+    void operator()( const vector_type &x , matrix_type &J , const double & , vector_type &dfdt )
     {
         J(0, 0) = 0.0;
         J(0, 1) = 1.0;
@@ -55,7 +55,7 @@ struct vdp_stiff_jacobi
 };
 
 
-int main( int argc , char **argv )
+int main()
 {
     //[ integrate_stiff_system
     vector_type x( 2 );
diff --git a/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp b/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp
index 3c5f2d46a..0fcf348ef 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 013a7acc4..e9f2f651d 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 6295c03a6..b92a6d1f5 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 d9c2359c3..50a99e5c4 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 83bbc1923..8b35e804e 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 8a5e60608..6bb307583 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 2d6291edf..e7bb90a89 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 d3240705b..5f814a91b 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 ad7332dca..e60564f5c 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 d7c3ccb97..8eaf26bd7 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 3645782ae..496aacca2 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 cd27990bd..965966b06 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 81ae249d1..c7f5b71b0 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 c8facfc46..dde16ccdb 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 13008caa3..759ef0d69 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 a274de4b2..6d27167a0 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 cb8e9c1c7..3ef00c923 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 ffad1a101..e44c8cdd5 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;
     };