Initial commit

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio.hpp

@@ -0,0 +1,14 @@
+//  ratio.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_HPP
+#define BOOST_RATIO_HPP
+
+#include <boost/ratio/include.hpp>
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/config.hpp

@@ -0,0 +1,96 @@
+//  config.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2012 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_CONFIG_HPP
+#define BOOST_RATIO_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+
+
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  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)
+#elif __cplusplus >= 201103L
+#define BOOST_RATIO_INTMAX_C(a) a##LL
+#else
+#define BOOST_RATIO_INTMAX_C(a) a##L
+#endif
+
+#ifdef UINTMAX_C
+#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
+#elif __cplusplus >= 201103L
+#define BOOST_RATIO_UINTMAX_C(a) a##ULL
+#else
+#define BOOST_RATIO_UINTMAX_C(a) a##UL
+#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

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/abs.hpp

@@ -0,0 +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
+// 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/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 // BOOST_MPL_ABS_HPP_INCLUDED

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/gcd.hpp

@@ -0,0 +1,124 @@
+////////////////////////////////////////////////////////////////////
+//
+// 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/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
+    , T n2
+    >
+struct gcd_c
+    : gcd<integral_c<T,n1>,integral_c<T,n2> >
+{
+};
+
+namespace aux {
+
+  // Workaround for error: the type of partial specialization template parameter constant "n2"
+    // depends on another template parameter
+    // Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
+#if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+
+  template< typename T1, boost::intmax_t n1, bool n1_is_0
+                  , typename T2, boost::intmax_t n2, bool n2_is_0 >
+      struct gcd_aux
+          : gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
+      struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
+      struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
+      {};
+
+#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+
+    template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
+    struct gcd_aux
+
+        : gcd_aux<T2, n2, n2==0,
+                    typename aux::largest_int<T1, T2>::type,
+                    //~ T1,
+                    (n1 % n2), (n1 % n2)==0>
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2>
+    struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2, bool C>
+    struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
+    {};
+#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+}
+
+template<>
+struct gcd_impl<integral_c_tag, integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+        : abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
+                        typename N2::value_type, N2::value, N2::value==0  > >
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_GCD_HPP_INCLUDED

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/lcm.hpp

@@ -0,0 +1,126 @@
+////////////////////////////////////////////////////////////////////
+//
+// 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/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
+    , T n2
+    >
+struct lcm_c
+    : lcm<integral_c<T,n1>,integral_c<T,n2> >
+{
+};
+
+
+namespace aux {
+  // Workaround for error: the type of partial specialization template parameter constant "n2"
+  // depends on another template parameter
+  // Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
+  #if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+  template< typename T1, boost::intmax_t n1, bool n1_is_0
+                          , typename T2, boost::intmax_t n2, bool n2_is_0 >
+      struct lcm_aux
+          : abs<integral_c< typename aux::largest_int<T1, T2>::type,
+              ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
+          > >
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
+      struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
+      {};
+
+      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
+      struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
+      {};
+
+
+#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+
+
+    template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
+    struct lcm_aux
+
+        : abs<integral_c< typename aux::largest_int<T1, T2>::type,
+            ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
+        > >
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2>
+    struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
+    {};
+
+    template <typename T1, T1 n1, typename T2, T2 n2, bool C>
+    struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
+    {};
+#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
+}
+
+template<>
+struct lcm_impl<integral_c_tag, integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+        : abs<aux::lcm_aux< typename N1::value_type, N1::value, N1::value==0,
+                        typename N2::value_type, N2::value, N2::value==0  > >
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_LCM_HPP_INCLUDED

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/sign.hpp

@@ -0,0 +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
+// 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/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 // BOOST_MPL_SIGN_HPP_INCLUDED

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/overflow_helpers.hpp

@@ -0,0 +1,367 @@
+//  ratio.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  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/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:
+      static const boost::intmax_t value = X + Y;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y>
+  class br_add<X, Y, 0>
+  {
+  public:
+      static const boost::intmax_t value = X;
+  };
+
+  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(min - Y <= X, BOOST_RATIO_OVERFLOW_IN_ADD, ());
+  public:
+      static const boost::intmax_t value = X + Y;
+  };
+
+  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
+  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::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 = 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,
+                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+                 >::value,
+                 R2::den
+             >
+         >::type type;
+  };
+  template <class R, boost::intmax_t D>
+  struct ratio_add<R, ratio<0,D> >
+  {
+    typedef R type;
+  };
+
+  template <class R1, class R2>
+  struct ratio_subtract
+  {
+      //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_sub
+                 <
+                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+                 >::value,
+                 R2::den
+             >
+         >::type type;
+  };
+
+  template <class R, boost::intmax_t D>
+  struct ratio_subtract<R, ratio<0,D> >
+  {
+    typedef R type;
+  };
+
+  template <class R1, class R2>
+  struct ratio_multiply
+  {
+      // The nested typedef type  shall be a synonym for ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type.
+      // 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_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value;
+     static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value;
+  public:
+      typedef typename ratio
+         <
+             boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
+             boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
+         >::type type;
+  };
+
+  template <class R1, class R2>
+  struct ratio_divide
+  {
+      // The nested typedef type  shall be a synonym for ratio<R1::num * R2::den, R2::num * R1::den>::type.
+      // 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:
+      typedef typename ratio
+         <
+             boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
+             boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
+         >::type type;
+  };
+  template <class R1, class R2>
+  struct is_evenly_divisible_by
+  {
+  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:
+      typedef integral_constant<bool,
+             ((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1)
+      > type;
+  };
+
+  template <class T>
+  struct is_ratio : public boost::false_type
+  {};
+  template <boost::intmax_t N, boost::intmax_t D>
+  struct is_ratio<ratio<N, D> > : public boost::true_type
+  {};
+
+  template <class R1, class R2,
+            boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den,
+            boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den>
+  struct ratio_less1
+  {
+    static const bool value = Q1 < Q2;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q>
+  struct ratio_less1<R1, R2, Q, 0, Q, 0>
+  {
+    static const bool value = false;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2>
+  struct ratio_less1<R1, R2, Q, 0, Q, M2>
+  {
+    static const bool value = true;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1>
+  struct ratio_less1<R1, R2, Q, M1, Q, 0>
+  {
+    static const bool value = false;
+  };
+
+  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2>
+  struct ratio_less1<R1, R2, Q, M1, Q, M2>
+  {
+    static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1>
+                                            >::value;
+  };
+
+  template <
+      class R1,
+      class R2,
+      boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value,
+    boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value
+>
+  struct ratio_less
+  {
+      static const bool value = S1 < S2;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less<R1, R2, 1LL, 1LL>
+  {
+      static const bool value = ratio_less1<R1, R2>::value;
+  };
+
+  template <class R1, class R2>
+  struct ratio_less<R1, R2, -1LL, -1LL>
+  {
+      static const bool value = ratio_less1<ratio<-R2::num, R2::den>,
+                                            ratio<-R1::num, R1::den> >::value;
+  };
+
+
+}  // namespace ratio_detail
+
+}  // namespace boost
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/include.hpp

@@ -0,0 +1,16 @@
+//  include.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_RATIO_INCLUDE_HPP
+#define BOOST_RATIO_INCLUDE_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/ratio_io.hpp>
+#ifdef BOOST_RATIO_EXTENSIONS
+#include <boost/ratio/mpl/rational_constant.hpp>
+#endif
+#endif  // BOOST_RATIO_INCLUDE_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/abs.hpp

@@ -0,0 +1,30 @@
+//  abs.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_ABS_HPP
+#define BOOST_RATIO_MPL_ABS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/abs.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct abs_impl< rational_c_tag >
+{
+    template< typename R > struct apply
+        : ratio_abs<R>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_ABS_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/arithmetic.hpp

@@ -0,0 +1,22 @@
+//  arithmetic.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_MPL_ARITHMETIC_HPP
+#define BOOST_RATIO_MPL_ARITHMETIC_HPP
+
+#include <boost/ratio/mpl/plus.hpp>
+#include <boost/ratio/mpl/minus.hpp>
+#include <boost/ratio/mpl/times.hpp>
+#include <boost/ratio/mpl/divides.hpp>
+#include <boost/ratio/mpl/negate.hpp>
+#include <boost/ratio/mpl/abs.hpp>
+#include <boost/ratio/mpl/sign.hpp>
+#include <boost/ratio/mpl/gcd.hpp>
+#include <boost/ratio/mpl/lcm.hpp>
+
+#endif  // BOOST_RATIO_MPL_ARITHMETIC_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/comparison.hpp

@@ -0,0 +1,19 @@
+//  comparison.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_MPL_COMPARISON_HPP
+#define BOOST_RATIO_MPL_COMPARISON_HPP
+
+#include <boost/ratio/mpl/equal_to.hpp>
+#include <boost/ratio/mpl/not_equal_to.hpp>
+#include <boost/ratio/mpl/less.hpp>
+#include <boost/ratio/mpl/less_equal.hpp>
+#include <boost/ratio/mpl/greater.hpp>
+#include <boost/ratio/mpl/greater_equal.hpp>
+
+#endif  // BOOST_RATIO_MPL_COMPARISON_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/divides.hpp

@@ -0,0 +1,30 @@
+//  divides.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_DIVIDES_HPP
+#define BOOST_RATIO_MPL_DIVIDES_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/divides.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct divides_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_divide<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_DIVIDES_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/equal_to.hpp

@@ -0,0 +1,30 @@
+//  equal_to.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_EQUAL_TO_HPP
+#define BOOST_RATIO_MPL_EQUAL_TO_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/equal_to.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct equal_to_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_EQUAL_TO_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/gcd.hpp

@@ -0,0 +1,30 @@
+//  gcd.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_GCD_HPP
+#define BOOST_RATIO_MPL_GCD_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/gcd.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct gcd_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_gcd<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_GCD_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/greater.hpp

@@ -0,0 +1,30 @@
+//  greater.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_GREATER_HPP
+#define BOOST_RATIO_MPL_GREATER_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/greater.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct greater_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_greater<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_GREATER_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/greater_equal.hpp

@@ -0,0 +1,30 @@
+//  greater_equal.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_GREATER_EQUAL_HPP
+#define BOOST_RATIO_MPL_GREATER_EQUAL_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/greater_equal.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct greater_equal_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_greater_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_GREATER_EQUAL_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/lcm.hpp

@@ -0,0 +1,30 @@
+//  lcm.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_LCM_HPP
+#define BOOST_RATIO_MPL_LCM_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/lcm.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct lcm_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_lcm<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_LCM_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/less.hpp

@@ -0,0 +1,30 @@
+//  less.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_LESS_HPP
+#define BOOST_RATIO_MPL_LESS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/less.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct less_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_less<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_LESS_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/less_equal.hpp

@@ -0,0 +1,30 @@
+//  less_equal.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_LESS_EQUAL_HPP
+#define BOOST_RATIO_MPL_LESS_EQUAL_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/less_equal.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct less_equal_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_less_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_LESS_EQUAL_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/minus.hpp

@@ -0,0 +1,30 @@
+//  minus.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_MINUS_HPP
+#define BOOST_RATIO_MPL_MINUS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/minus.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct minus_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_subtract<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_MINUS_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/negate.hpp

@@ -0,0 +1,30 @@
+//  negate.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_NEGATE_HPP
+#define BOOST_RATIO_MPL_NEGATE_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/negate.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct negate_impl< rational_c_tag >
+{
+    template< typename R > struct apply
+        : ratio_negate<R>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_NEGATE_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/not_equal_to.hpp

@@ -0,0 +1,30 @@
+//  not_equal_to.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP
+#define BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/not_equal_to.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct not_equal_to_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_not_equal<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/numeric_cast.hpp

@@ -0,0 +1,31 @@
+//  numeric_cast.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_NUMERIC_CAST_HPP
+#define BOOST_RATIO_MPL_NUMERIC_CAST_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/ratio/mpl/rational_c_tag.hpp>
+#include <boost/mpl/numeric_cast.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<> struct numeric_cast< integral_c_tag,rational_c_tag >
+{
+    template< typename N > struct apply
+        : ratio< N::value, 1 >
+    {
+    };
+};
+    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_NUMERIC_CAST_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/plus.hpp

@@ -0,0 +1,30 @@
+//  plus.hpp
+//
+//  (C) Copyright 2011Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_PLUS_HPP
+#define BOOST_RATIO_MPL_PLUS_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/plus.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct plus_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_add<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_PLUS_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/rational_c_tag.hpp

@@ -0,0 +1,25 @@
+//  abs.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP
+#define BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP
+
+#ifdef BOOST_RATIO_EXTENSIONS
+
+#include <boost/mpl/int.hpp>
+
+namespace boost {
+namespace mpl {
+
+struct rational_c_tag : int_<10> {};
+
+}
+}
+
+#endif // BOOST_RATIO_EXTENSIONS
+#endif  // BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/rational_constant.hpp

@@ -0,0 +1,15 @@
+//  rational_constant.hpp  ---------------------------------------------------------------//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_RATIO_MPL_RATIONAL_CONSTANT_HPP
+#define BOOST_RATIO_MPL_RATIONAL_CONSTANT_HPP
+
+#include <boost/ratio/mpl/rational_c_tag.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/mpl/arithmetic.hpp>
+#include <boost/ratio/mpl/comparison.hpp>
+
+#endif  // BOOST_RATIO_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/sign.hpp

@@ -0,0 +1,30 @@
+//  sign.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_SIGN_HPP
+#define BOOST_RATIO_MPL_SIGN_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/ratio/detail/mpl/sign.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct sign_impl< rational_c_tag >
+{
+    template< typename R > struct apply
+        : ratio_sign<R>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_SIGN_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/times.hpp

@@ -0,0 +1,30 @@
+//  times.hpp
+//
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+
+#ifndef BOOST_RATIO_MPL_TIMES_HPP
+#define BOOST_RATIO_MPL_TIMES_HPP
+
+#include <boost/ratio/ratio.hpp>
+#include <boost/ratio/mpl/numeric_cast.hpp>
+#include <boost/mpl/times.hpp>
+
+namespace boost { 
+namespace mpl {
+
+template<>
+struct times_impl< rational_c_tag,rational_c_tag >
+{
+    template< typename R1, typename R2 > struct apply
+        : ratio_multiply<R1, R2>
+    {
+    };
+};    
+}
+}
+
+#endif  // BOOST_RATIO_MPL_TIMES_HPP

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/ratio.hpp

@@ -0,0 +1,293 @@
+//  ratio.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  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_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/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;
+    BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
+    BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
+    BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ());
+    static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
+      * mpl::sign_c<boost::intmax_t,D>::value;
+    static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
+public:
+    BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD;
+    BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD;
+
+#ifdef BOOST_RATIO_EXTENSIONS
+    typedef mpl::rational_c_tag tag;
+    typedef boost::rational<boost::intmax_t> value_type;
+    typedef boost::intmax_t num_type;
+    typedef boost::intmax_t den_type;
+    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]         //
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+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 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

externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/ratio_fwd.hpp

@@ -0,0 +1,109 @@
+//  ratio_fwd.hpp  ---------------------------------------------------------------//
+
+//  Copyright 2008 Howard Hinnant
+//  Copyright 2008 Beman Dawes
+//  Copyright 2009 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  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_RATIO_FWD_HPP
+#define BOOST_RATIO_RATIO_FWD_HPP
+
+#include <boost/ratio/config.hpp>
+
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif
+
+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