8 files changed, 103 insertions, 16 deletions
diff --git a/3rdParty/Boost/src/boost/ratio/config.hpp b/3rdParty/Boost/src/boost/ratio/config.hpp
index 67a60fc..992a256 100644
--- a/3rdParty/Boost/src/boost/ratio/config.hpp
+++ b/3rdParty/Boost/src/boost/ratio/config.hpp
@@ -17,70 +17,76 @@
 #  if ! defined BOOST_NO_CXX11_U16STRING
 #    define BOOST_NO_CXX11_U16STRING
 #  endif
 #  if ! defined BOOST_NO_CXX11_U32STRING
 #    define BOOST_NO_CXX11_U32STRING
 #  endif
 #endif
 
 
 #if !defined BOOST_RATIO_VERSION
 #define BOOST_RATIO_VERSION 1
 #else
 #if BOOST_RATIO_VERSION!=1  && BOOST_RATIO_VERSION!=2
 #error "BOOST_RATIO_VERSION must be 1 or 2"
 #endif
 #endif
 
 #if BOOST_RATIO_VERSION==1
 #if ! defined BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
 #define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
 #endif
 #endif
 
 #if BOOST_RATIO_VERSION==2
 #if ! defined BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
 #define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
 #endif
 #endif
 
 #ifdef INTMAX_C
 #define BOOST_RATIO_INTMAX_C(a) INTMAX_C(a)
 #else
 #define BOOST_RATIO_INTMAX_C(a) a##LL
 #endif
 
+#ifdef UINTMAX_C
+#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
+#else
+#define BOOST_RATIO_UINTMAX_C(a) a##ULL
+#endif
+
 #define BOOST_RATIO_INTMAX_T_MAX (0x7FFFFFFFFFFFFFFELL)
 
 
 #ifndef BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
 #elif defined(BOOST_RATIO_USES_STATIC_ASSERT)
 #include <boost/static_assert.hpp>
 #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
 #elif defined(BOOST_RATIO_USES_MPL_ASSERT)
 #include <boost/mpl/assert.hpp>
 #include <boost/mpl/bool.hpp>
 #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)                                 \
     BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
 #else
 //~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT)
 #define BOOST_RATIO_CONCAT(A,B) A##B
 #define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B)
 #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1]
 //~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
 #endif
 
 #if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT)
 #define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add"
 #define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub"
 #define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul"
 #define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div"
 #define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
 #define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0"
 #define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
 #endif
 
 
 //#define BOOST_RATIO_EXTENSIONS
 
 #endif  // header
diff --git a/3rdParty/Boost/src/boost/ratio/detail/mpl/abs.hpp b/3rdParty/Boost/src/boost/ratio/detail/mpl/abs.hpp
index 4be1274..9154588 100644
--- a/3rdParty/Boost/src/boost/ratio/detail/mpl/abs.hpp
+++ b/3rdParty/Boost/src/boost/ratio/detail/mpl/abs.hpp
@@ -1,89 +1,89 @@
 ////////////////////////////////////////////////////////////////////
 //
 // Copyright Vicente J. Botet Escriba 2010
 //
-// Distributed under the Boost Software License, Version 1.0. 
-// (See accompanying file LICENSE_1_0.txt or copy at 
+// 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)
 //
 // See http://www.boost.org/libs/mpl for documentation.
 //
 ////////////////////////////////////////////////////////////////////
 #ifndef BOOST_MPL_ABS_HPP_INCLUDED
 #define BOOST_MPL_ABS_HPP_INCLUDED
 
 #include <boost/mpl/integral_c.hpp>
 #include <boost/mpl/aux_/na_spec.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/aux_/config/eti.hpp>
 #include <boost/mpl/aux_/config/integral.hpp>
 #include <boost/mpl/aux_/config/static_constant.hpp>
 
 #if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
     && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
     && ( defined(BOOST_MSVC) \
         || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
         )
 
 #   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
 
 #endif
 
 namespace boost { namespace mpl {
 
 template< typename Tag > struct abs_impl;
 
 template< typename T > struct abs_tag
 {
     typedef typename T::tag type;
 };
 
 template<
       typename BOOST_MPL_AUX_NA_PARAM(N)
     >
 struct abs
     : abs_impl<
           typename abs_tag<N>::type
         >::template apply<N>::type
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1, abs, (N))
 };
 
 BOOST_MPL_AUX_NA_SPEC(1, abs)
 
 template<
       typename T
     , T n1
     >
 struct abs_c
     : abs<integral_c<T,n1> >
 {
 };
 
 #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
 namespace aux {
 template< typename T, T n > struct abs_wknd
 {
     BOOST_STATIC_CONSTANT(T, value = (n < 0 ? -n : n));
     typedef integral_c<T,value> type;
 };
 }
 #endif
 
 template<>
 struct abs_impl<integral_c_tag>
 {
 #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
     template< typename N > struct apply
         : aux::abs_wknd< typename N::value_type, N::value >
 #else
     template< typename N > struct apply
         : integral_c< typename N::value_type, ((N::value < 0) ? (-N::value) : N::value ) >
-#endif    
+#endif
     {
     };
 };
 
 }}
 
 #endif // BOOST_MPL_ABS_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/ratio/detail/mpl/gcd.hpp b/3rdParty/Boost/src/boost/ratio/detail/mpl/gcd.hpp
index c8258cf..30ba1db 100644
--- a/3rdParty/Boost/src/boost/ratio/detail/mpl/gcd.hpp
+++ b/3rdParty/Boost/src/boost/ratio/detail/mpl/gcd.hpp
@@ -1,62 +1,62 @@
 ////////////////////////////////////////////////////////////////////
 //
 // Copyright Vicente J. Botet Escriba 2010
 //
 // 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)
 //
 // See http://www.boost.org/libs/mpl for documentation.
 //
 ////////////////////////////////////////////////////////////////////
 #ifndef BOOST_MPL_GCD_HPP_INCLUDED
 #define BOOST_MPL_GCD_HPP_INCLUDED
 
 #include <boost/mpl/integral_c.hpp>
 #include <boost/ratio/detail/mpl/abs.hpp>
 #include <boost/mpl/aux_/largest_int.hpp>
 #include <boost/mpl/aux_/na_spec.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/aux_/config/eti.hpp>
 #include <boost/mpl/aux_/config/integral.hpp>
 #include <boost/mpl/aux_/config/static_constant.hpp>
 #include <boost/mpl/aux_/config/dependent_nttp.hpp>
 #include <boost/cstdint.hpp>
 
 #if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
     && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
     && ( defined(BOOST_MSVC) \
         || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
         )
 
 #   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
 
 #endif
 
 namespace boost { namespace mpl {
 
 template< typename Tag1, typename Tag2 > struct gcd_impl;
 
 template< typename T > struct gcd_tag
 {
     typedef typename T::tag type;
 };
 
 template<
       typename BOOST_MPL_AUX_NA_PARAM(N1)
     , typename BOOST_MPL_AUX_NA_PARAM(N2)
     >
 struct gcd
     : gcd_impl<
           typename gcd_tag<N1>::type
         , typename gcd_tag<N2>::type
         >::template apply<N1, N2>::type
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(2, gcd, (N1, N2))
 };
 
 BOOST_MPL_AUX_NA_SPEC(2, gcd)
 
 template<
       typename T
     , T n1
diff --git a/3rdParty/Boost/src/boost/ratio/detail/mpl/lcm.hpp b/3rdParty/Boost/src/boost/ratio/detail/mpl/lcm.hpp
index 546d0e1..1792660 100644
--- a/3rdParty/Boost/src/boost/ratio/detail/mpl/lcm.hpp
+++ b/3rdParty/Boost/src/boost/ratio/detail/mpl/lcm.hpp
@@ -1,62 +1,62 @@
 ////////////////////////////////////////////////////////////////////
 //
 // Copyright Vicente J. Botet Escriba 2010
 //
 // 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)
 //
 // See http://www.boost.org/libs/mpl for documentation.
 //
 ////////////////////////////////////////////////////////////////////
 #ifndef BOOST_MPL_LCM_HPP_INCLUDED
 #define BOOST_MPL_LCM_HPP_INCLUDED
 
 #include <boost/mpl/integral_c.hpp>
 #include <boost/ratio/detail/mpl/abs.hpp>
 #include <boost/mpl/aux_/largest_int.hpp>
 #include <boost/mpl/aux_/na_spec.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/aux_/config/eti.hpp>
 #include <boost/mpl/aux_/config/integral.hpp>
 #include <boost/mpl/aux_/config/static_constant.hpp>
 #include <boost/mpl/aux_/config/dependent_nttp.hpp>
 #include <boost/cstdint.hpp>
 
 #if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
     && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
     && ( defined(BOOST_MSVC) \
         || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
         )
 
 #   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
 
 #endif
 
 namespace boost { namespace mpl {
 
 template< typename Tag1, typename Tag2 > struct lcm_impl;
 
 template< typename T > struct lcm_tag
 {
     typedef typename T::tag type;
 };
 
 template<
       typename BOOST_MPL_AUX_NA_PARAM(N1)
     , typename BOOST_MPL_AUX_NA_PARAM(N2)
     >
 struct lcm
     : lcm_impl<
           typename lcm_tag<N1>::type
         , typename lcm_tag<N2>::type
         >::template apply<N1, N2>::type
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(2, lcm, (N1, N2))
 };
 
 BOOST_MPL_AUX_NA_SPEC(2, lcm)
 
 template<
       typename T
     , T n1
diff --git a/3rdParty/Boost/src/boost/ratio/detail/mpl/sign.hpp b/3rdParty/Boost/src/boost/ratio/detail/mpl/sign.hpp
index af201eb..fa1c555 100644
--- a/3rdParty/Boost/src/boost/ratio/detail/mpl/sign.hpp
+++ b/3rdParty/Boost/src/boost/ratio/detail/mpl/sign.hpp
@@ -1,89 +1,89 @@
 ////////////////////////////////////////////////////////////////////
 //
 // Copyright Vicente J. Botet Escriba 2010
 //
-// Distributed under the Boost Software License, Version 1.0. 
-// (See accompanying file LICENSE_1_0.txt or copy at 
+// 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)
 //
 // See http://www.boost.org/libs/mpl for documentation.
 //
 ////////////////////////////////////////////////////////////////////
 #ifndef BOOST_MPL_SIGN_HPP_INCLUDED
 #define BOOST_MPL_SIGN_HPP_INCLUDED
 
 #include <boost/mpl/integral_c.hpp>
 #include <boost/mpl/aux_/na_spec.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/aux_/config/eti.hpp>
 #include <boost/mpl/aux_/config/integral.hpp>
 #include <boost/mpl/aux_/config/static_constant.hpp>
 
 #if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
     && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && !defined(__CUDACC__) \
     && ( defined(BOOST_MSVC) \
         || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
         )
 
 #   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
 
 #endif
 
 namespace boost { namespace mpl {
 
 template< typename Tag > struct sign_impl;
 
 template< typename T > struct sign_tag
 {
     typedef typename T::tag type;
 };
 
 template<
       typename BOOST_MPL_AUX_NA_PARAM(N)
     >
 struct sign
     : sign_impl<
           typename sign_tag<N>::type
         >::template apply<N>::type
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1, sign, (N))
 };
 
 BOOST_MPL_AUX_NA_SPEC(1, sign)
 
 template<
       typename T
     , T n1
     >
 struct sign_c
     : sign<integral_c<T,n1> >
 {
 };
 
 #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
 namespace aux {
 template< typename T, T n > struct sign_wknd
 {
     BOOST_STATIC_CONSTANT(T, value = (n == 0 ? 0 : (n < 0 ? -1 : 1)));
     typedef integral_c<T,value> type;
 };
 }
 #endif
 
 template<>
 struct sign_impl<integral_c_tag>
 {
 #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
     template< typename N > struct apply
         : aux::sign_wknd< typename N::value_type, N::value >
 #else
     template< typename N > struct apply
         : integral_c< typename N::value_type, (N::value == 0 ? 0 : (N::value < 0 ? -1 : 1)) >
-#endif    
+#endif
     {
     };
 };
 
 }}
 
 #endif // BOOST_MPL_SIGN_HPP_INCLUDED
diff --git a/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp b/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp
index 0e292fa..ffaa603 100644
--- a/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp
+++ b/3rdParty/Boost/src/boost/ratio/detail/overflow_helpers.hpp
@@ -8,71 +8,71 @@
 //  See http://www.boost.org/LICENSE_1_0.txt
 
 /*
 
 This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
 Many thanks to Howard for making his code available under the Boost license.
 The original code was modified to conform to Boost conventions and to section
 20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
 paper N2798.
 See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
 
 time2_demo contained this comment:
 
     Much thanks to Andrei Alexandrescu,
                    Walter Brown,
                    Peter Dimov,
                    Jeff Garland,
                    Terry Golubiewski,
                    Daniel Krugler,
                    Anthony Williams.
 */
 
 // The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
 
 #ifndef BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP
 #define BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP
 
 #include <boost/ratio/config.hpp>
 #include <boost/ratio/detail/mpl/abs.hpp>
 #include <boost/ratio/detail/mpl/sign.hpp>
 #include <cstdlib>
 #include <climits>
 #include <limits>
 #include <boost/cstdint.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/integer_traits.hpp>
 
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
 //
 // boost/integer.hpp:77:30: warning: use of C99 long long integer constant
 //
 // And yet there is no other reasonable implementation, so we declare this a system header
 // to suppress these warnings.
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
 
 namespace boost
 {
 
 //----------------------------------------------------------------------------//
 //                                 helpers                                    //
 //----------------------------------------------------------------------------//
 
 namespace ratio_detail
 {
 
   template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
   class br_add;
 
   template <boost::intmax_t X, boost::intmax_t Y>
   class br_add<X, Y, 1>
   {
       static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
       static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
 
       BOOST_RATIO_STATIC_ASSERT(X <= max - Y , BOOST_RATIO_OVERFLOW_IN_ADD, ());
   public:
@@ -101,110 +101,110 @@ namespace ratio_detail
   class br_sub;
 
   template <boost::intmax_t X, boost::intmax_t Y>
   class br_sub<X, Y, 1>
   {
       static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
       static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
 
       BOOST_RATIO_STATIC_ASSERT(min + Y <= X, BOOST_RATIO_OVERFLOW_IN_SUB, ());
   public:
       static const boost::intmax_t value = X - Y;
   };
 
   template <boost::intmax_t X, boost::intmax_t Y>
   class br_sub<X, Y, 0>
   {
   public:
       static const boost::intmax_t value = X;
   };
 
   template <boost::intmax_t X, boost::intmax_t Y>
   class br_sub<X, Y, -1>
   {
       static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
       static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
 
       BOOST_RATIO_STATIC_ASSERT(X <= max + Y, BOOST_RATIO_OVERFLOW_IN_SUB, ());
   public:
       static const boost::intmax_t value = X - Y;
   };
 
   template <boost::intmax_t X, boost::intmax_t Y>
   class br_mul
   {
       static const boost::intmax_t nan =
-        (BOOST_RATIO_INTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
+          boost::intmax_t(BOOST_RATIO_UINTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
       static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
       static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
 
       static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value;
       static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value;
 
       BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ());
       BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ());
       BOOST_RATIO_STATIC_ASSERT(a_x <= max / a_y, BOOST_RATIO_OVERFLOW_IN_MUL, ());
   public:
       static const boost::intmax_t value = X * Y;
   };
 
   template <boost::intmax_t Y>
   class br_mul<0, Y>
   {
   public:
       static const boost::intmax_t value = 0;
   };
 
   template <boost::intmax_t X>
   class br_mul<X, 0>
   {
   public:
       static const boost::intmax_t value = 0;
   };
 
   template <>
   class br_mul<0, 0>
   {
   public:
       static const boost::intmax_t value = 0;
   };
 
   // Not actually used but left here in case needed in future maintenance
   template <boost::intmax_t X, boost::intmax_t Y>
   class br_div
   {
-      static const boost::intmax_t nan = (1LL << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
+      static const boost::intmax_t nan = boost::intmax_t(BOOST_RATIO_UINTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
       static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
       static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
 
       BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ());
       BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ());
       BOOST_RATIO_STATIC_ASSERT(Y != 0, BOOST_RATIO_DIVIDE_BY_0, ());
   public:
       static const boost::intmax_t value = X / Y;
   };
 
   // ratio arithmetic
   template <class R1, class R2> struct ratio_add;
   template <class R1, class R2> struct ratio_subtract;
   template <class R1, class R2> struct ratio_multiply;
   template <class R1, class R2> struct ratio_divide;
 
   template <class R1, class R2>
   struct ratio_add
   {
       //The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num *
       //R2::den + R2::num * R1::den and T2 has the value R1::den * R2::den.
       // As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
   private:
       static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
       static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
   public:
       // No need to normalize as ratio_multiply is already normalized
       typedef typename ratio_multiply
          <
              ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
              ratio
              <
                  boost::ratio_detail::br_add
                  <
                      boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
diff --git a/3rdParty/Boost/src/boost/ratio/ratio.hpp b/3rdParty/Boost/src/boost/ratio/ratio.hpp
index 546e8f0..824cbf0 100644
--- a/3rdParty/Boost/src/boost/ratio/ratio.hpp
+++ b/3rdParty/Boost/src/boost/ratio/ratio.hpp
@@ -10,71 +10,71 @@
 /*
 
 This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
 Many thanks to Howard for making his code available under the Boost license.
 The original code was modified to conform to Boost conventions and to section
 20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
 paper N2798.
 See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
 
 time2_demo contained this comment:
 
     Much thanks to Andrei Alexandrescu,
                    Walter Brown,
                    Peter Dimov,
                    Jeff Garland,
                    Terry Golubiewski,
                    Daniel Krugler,
                    Anthony Williams.
 */
 
 // The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
 
 #ifndef BOOST_RATIO_RATIO_HPP
 #define BOOST_RATIO_RATIO_HPP
 
 #include <boost/ratio/config.hpp>
 #include <boost/ratio/detail/mpl/abs.hpp>
 #include <boost/ratio/detail/mpl/sign.hpp>
 #include <boost/ratio/detail/mpl/gcd.hpp>
 #include <boost/ratio/detail/mpl/lcm.hpp>
 #include <cstdlib>
 #include <climits>
 #include <limits>
 #include <boost/cstdint.hpp>
 #include <boost/type_traits/integral_constant.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/integer_traits.hpp>
 #include <boost/ratio/ratio_fwd.hpp>
 #include <boost/ratio/detail/overflow_helpers.hpp>
 #ifdef BOOST_RATIO_EXTENSIONS
 #include <boost/rational.hpp>
 #include <boost/ratio/mpl/rational_c_tag.hpp>
 #endif
 
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
 //
 // boost/integer.hpp:77:30: warning: use of C99 long long integer constant
 //
 // And yet there is no other reasonable implementation, so we declare this a system header
 // to suppress these warnings.
 //
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
 
 namespace boost
 {
 
 
 //----------------------------------------------------------------------------//
 //                                                                            //
 //                20.6.1 Class template ratio [ratio.ratio]                   //
 //                                                                            //
 //----------------------------------------------------------------------------//
 
 template <boost::intmax_t N, boost::intmax_t D>
 class ratio
 {
     static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
     static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
@@ -96,138 +96,198 @@ public:
     ratio()
     {}
     template <boost::intmax_t _N2, boost::intmax_t _D2>
     ratio(const ratio<_N2, _D2>&,
         typename enable_if_c
             <
                 (ratio<_N2, _D2>::num == num &&
                 ratio<_N2, _D2>::den == den)
             >::type* = 0)
     {}
 
     template <boost::intmax_t _N2, boost::intmax_t _D2>
         typename enable_if_c
         <
             (ratio<_N2, _D2>::num == num &&
             ratio<_N2, _D2>::den == den),
             ratio&
         >::type
     operator=(const ratio<_N2, _D2>&) {return *this;}
 
     static value_type value() {return value_type(num,den);}
     value_type operator()() const {return value();}
 #endif
     typedef ratio<num, den> type;
 };
 
 #if defined(BOOST_NO_CXX11_CONSTEXPR)
 template <boost::intmax_t N, boost::intmax_t D>
 const    boost::intmax_t ratio<N, D>::num;
 template <boost::intmax_t N, boost::intmax_t D>
 const    boost::intmax_t ratio<N, D>::den;
 #endif
 
 //----------------------------------------------------------------------------//
 //                                                                            //
-//                20.6.2 Arithmetic on ratio types [ratio.arithmetic]                   //
+//                20.6.2 Arithmetic on ratio types [ratio.arithmetic]         //
 //                                                                            //
 //----------------------------------------------------------------------------//
 
 template <class R1, class R2>
 struct ratio_add
 : boost::ratio_detail::ratio_add<R1, R2>::type
 {
 };
 
 template <class R1, class R2>
 struct ratio_subtract
 : boost::ratio_detail::ratio_subtract<R1, R2>::type
 {
 };
 
 template <class R1, class R2>
 struct ratio_multiply
 : boost::ratio_detail::ratio_multiply<R1, R2>::type
 {
 };
 
 template <class R1, class R2>
 struct ratio_divide
 : boost::ratio_detail::ratio_divide<R1, R2>::type
 {
 };
 
 //----------------------------------------------------------------------------//
 //                                                                            //
-//                20.6.3 Comparasion of ratio types [ratio.comparison]                   //
+//                20.6.3 Comparision of ratio types [ratio.comparison]        //
 //                                                                            //
 //----------------------------------------------------------------------------//
 
 // ratio_equal
 
 template <class R1, class R2>
 struct ratio_equal
     : public boost::integral_constant<bool,
                                (R1::num == R2::num && R1::den == R2::den)>
 {};
 
 template <class R1, class R2>
 struct ratio_not_equal
     : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
 {};
 
 // ratio_less
 
 template <class R1, class R2>
 struct ratio_less
     : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
 {};
 
 template <class R1, class R2>
 struct ratio_less_equal
     : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
 {};
 
 template <class R1, class R2>
 struct ratio_greater
     : boost::integral_constant<bool, ratio_less<R2, R1>::value>
 {};
 
 template <class R1, class R2>
 struct ratio_greater_equal
     : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
 {};
 
 template <class R1, class R2>
 struct ratio_gcd :
     ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
         mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
 {
 };
 
+    //----------------------------------------------------------------------------//
+    //                                                                            //
+    //                More arithmetic on ratio types [ratio.arithmetic]           //
+    //                                                                            //
+    //----------------------------------------------------------------------------//
+
 #ifdef BOOST_RATIO_EXTENSIONS
 template <class R>
 struct ratio_negate
     : ratio<-R::num, R::den>::type
 {
 };
 template <class R>
 struct ratio_abs
     : ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type
 {
 };
 template <class R>
 struct ratio_sign
     : mpl::sign_c<boost::intmax_t, R::num>
 {
 };
+
+template <class R>
+struct ratio_inverse
+    : ratio<R::den, R::num>::type
+{
+};
+
+
 template <class R1, class R2>
 struct ratio_lcm :
     ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value,
         mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type
 {
 };
+
+template <class R1, class R2>
+struct ratio_modulo :
+    ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type
+{
+};
+
+namespace detail {
+  template <class R1, class R2, bool r1ltr2>
+  struct ratio_min : R1 {};
+  template <class R1, class R2>
+  struct ratio_min<R1,R2,false> : R2 {};
+
+  template <class R1, class R2, bool r1ltr2>
+  struct ratio_max : R2 {};
+  template <class R1, class R2>
+  struct ratio_max<R1,R2,false> : R1 {};
+}
+
+template <class R1, class R2>
+struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type
+{
+};
+
+template <class R1, class R2>
+struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type
+{
+};
+
+template<typename R, int p>
+struct ratio_power :
+  ratio_multiply<
+    typename ratio_power<R, p%2>::type,
+    typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type
+  >::type
+{};
+
+template<typename R>
+struct ratio_power<R, 0> : ratio<1>::type {};
+
+template<typename R>
+struct ratio_power<R, 1> : R {};
+
+template<typename R>
+struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {};
+
 #endif
 }  // namespace boost
 
 
 #endif  // BOOST_RATIO_RATIO_HPP
diff --git a/3rdParty/Boost/src/boost/ratio/ratio_fwd.hpp b/3rdParty/Boost/src/boost/ratio/ratio_fwd.hpp
index 0882e0b..0836d55 100644
--- a/3rdParty/Boost/src/boost/ratio/ratio_fwd.hpp
+++ b/3rdParty/Boost/src/boost/ratio/ratio_fwd.hpp
@@ -19,66 +19,87 @@ See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
 time2_demo contained this comment:
 
     Much thanks to Andrei Alexandrescu,
                    Walter Brown,
                    Peter Dimov,
                    Jeff Garland,
                    Terry Golubiewski,
                    Daniel Krugler,
                    Anthony Williams.
 */
 
 // The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
 
 #ifndef BOOST_RATIO_RATIO_FWD_HPP
 #define BOOST_RATIO_RATIO_FWD_HPP
 
 #include <boost/ratio/config.hpp>
 
 namespace boost
 {
 
 //----------------------------------------------------------------------------//
 //                                                                            //
 //              20.6 Compile-time rational arithmetic [ratio]                 //
 //                                                                            //
 //----------------------------------------------------------------------------//
 
 // ratio
 template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
 
 // ratio arithmetic
 template <class R1, class R2> struct ratio_add;
 template <class R1, class R2> struct ratio_subtract;
 template <class R1, class R2> struct ratio_multiply;
 template <class R1, class R2> struct ratio_divide;
+#ifdef BOOST_RATIO_EXTENSIONS
+template <class R1, class R2> struct ratio_gcd;
+template <class R1, class R2> struct ratio_lcm;
+template <class R> struct ratio_negate;
+template <class R> struct ratio_abs;
+template <class R> struct ratio_sign;
+template <class R, int P> struct ratio_power;
+#endif
 
 // ratio comparison
 template <class R1, class R2> struct ratio_equal;
 template <class R1, class R2> struct ratio_not_equal;
 template <class R1, class R2> struct ratio_less;
 template <class R1, class R2> struct ratio_less_equal;
 template <class R1, class R2> struct ratio_greater;
 template <class R1, class R2> struct ratio_greater_equal;
 
 // convenience SI typedefs
 typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000000000000)> atto;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),    BOOST_RATIO_INTMAX_C(1000000000000000)> femto;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),       BOOST_RATIO_INTMAX_C(1000000000000)> pico;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),          BOOST_RATIO_INTMAX_C(1000000000)> nano;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),             BOOST_RATIO_INTMAX_C(1000000)> micro;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),                BOOST_RATIO_INTMAX_C(1000)> milli;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),                 BOOST_RATIO_INTMAX_C(100)> centi;
 typedef ratio<BOOST_RATIO_INTMAX_C(1),                  BOOST_RATIO_INTMAX_C(10)> deci;
 typedef ratio<                 BOOST_RATIO_INTMAX_C(10), BOOST_RATIO_INTMAX_C(1)> deca;
 typedef ratio<                BOOST_RATIO_INTMAX_C(100), BOOST_RATIO_INTMAX_C(1)> hecto;
 typedef ratio<               BOOST_RATIO_INTMAX_C(1000), BOOST_RATIO_INTMAX_C(1)> kilo;
 typedef ratio<            BOOST_RATIO_INTMAX_C(1000000), BOOST_RATIO_INTMAX_C(1)> mega;
 typedef ratio<         BOOST_RATIO_INTMAX_C(1000000000), BOOST_RATIO_INTMAX_C(1)> giga;
 typedef ratio<      BOOST_RATIO_INTMAX_C(1000000000000), BOOST_RATIO_INTMAX_C(1)> tera;
 typedef ratio<   BOOST_RATIO_INTMAX_C(1000000000000000), BOOST_RATIO_INTMAX_C(1)> peta;
 typedef ratio<BOOST_RATIO_INTMAX_C(1000000000000000000), BOOST_RATIO_INTMAX_C(1)> exa;
 
+#ifdef BOOST_RATIO_EXTENSIONS
+
+#define BOOST_RATIO_1024 BOOST_RATIO_INTMAX_C(1024)
+
+// convenience IEC typedefs
+typedef ratio<                                                                                     BOOST_RATIO_1024> kibi;
+typedef ratio<                                                                    BOOST_RATIO_1024*BOOST_RATIO_1024> mebi;
+typedef ratio<                                                   BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> gibi;
+typedef ratio<                                  BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> tebi;
+typedef ratio<                 BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> pebi;
+typedef ratio<BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> exbi;
+
+#endif
 }  // namespace boost
 
 
 #endif  // BOOST_RATIO_HPP