Update contrib/restricted/boost/math to 1.85.0

0ec0342a652b8bc4a78b299b1a5683310c65df58

7 files changed, 170 insertions, 101 deletions

diff --git a/contrib/restricted/boost/math/README.md b/contrib/restricted/boost/math/README.md
index 07c6c4604b..a20120e8ab 100644
--- a/contrib/restricted/boost/math/README.md
+++ b/contrib/restricted/boost/math/README.md
@@ -1,10 +1,24 @@
-Boost Math Library 
-[![Build Status](https://drone.cpp.al/api/badges/boostorg/math/status.svg)](https://drone.cpp.al/boostorg/math)[![Build Status](https://github.com/boostorg/math/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/math/actions)
-==================
+Boost Math Library
+============================
 
->ANNOUNCEMENT: This library now requires a compliant C++14 compiler.
+>ANNOUNCEMENT: This library requires a compliant C++14 compiler.
 
-This library is divided into several interconnected parts:
+|                  |  Master  |   Develop   |
+|------------------|----------|-------------|
+| Drone            | [![Build Status](https://drone.cpp.al/api/badges/boostorg/math/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/math)   | [![Build Status](https://drone.cpp.al/api/badges/boostorg/math/status.svg)](https://drone.cpp.al/boostorg/math) |
+| Github Actions   | [![Build Status](https://github.com/boostorg/math/workflows/CI/badge.svg?branch=master)](https://github.com/boostorg/math/actions)      | [![Build Status](https://github.com/boostorg/math/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/math/actions) |
+| Codecov          | [![codecov](https://codecov.io/gh/boostorg/math/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/math/branch/master)      | [![codecov](https://codecov.io/gh/boostorg/math/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/math/branch/develop) |
+
+
+The Math library provides numerous advanced mathematical functions
+implemented in modern C++. The library strives to deliver the utmost
+in numerical and syntactical correctness while still
+maintaining high-performance.
+
+All code is header-only, facilitating easy client setup
+and use throughout the entire diverse collection of functions.
+
+The library is divided into several interconnected parts:
 
 ### Floating Point Utilities
 
@@ -30,19 +44,33 @@ A comprehensive tutorial is provided, along with a series of worked examples ill
 
 ### Special Functions
 
-Provides a small number of high quality special functions; initially these were concentrated on functions used in statistical applications along with those in the Technical Report on C++ Library Extensions.
+Provides a wide range of high quality special functions; initially these were concentrated
+on functions used in statistical applications along with those in the Technical Report
+on C++ Library Extensions.
 
-The function families currently implemented are the gamma, beta & error functions along with the incomplete gamma and beta functions (four variants of each) and all the possible inverses of these, plus the digamma, various factorial functions, Bessel functions, elliptic integrals, hypergeometrics, sinus cardinals (along with their hyperbolic variants), inverse hyperbolic functions, Legrendre/Laguerre/Hermite/Chebyshev polynomials and various special power and logarithmic functions.
+The function families currently implemented are the gamma, beta and error functions
+along with the incomplete gamma and beta functions (four variants of each)
+and all the possible inverses of these, plus the digamma, various factorial
+functions, Bessel functions, elliptic integrals, hypergeometrics, sinus cardinals
+(along with their hyperbolic variants), inverse hyperbolic functions,
+Legrendre/Laguerre/Hermite/Chebyshev polynomials
+and various special power and logarithmic functions.
 
-All the implementations are fully generic and support the use of arbitrary "real-number" types, including Boost.Multiprecision, although they are optimised for use with types with known significand (or mantissa) sizes: typically float, double or long double.
+All the implementations are fully generic and support the use of arbitrary "real-number" types,
+including those in [Boost.Multiprecision](https://github.com/boostorg/multiprecision).
+Most functions are, however, optimized for use with types with known significand (or mantissa) sizes:
+typically built-in `float`, `double` or `long double`.
 
-These functions also provide the basis of support for the TR1 special functions.
+These functions also provide the basis of support for the TR1 special functions,
+many of which became standardized in [C++17](https://en.cppreference.com/w/cpp/numeric/special_functions).
 
-### Root Finding and Function Minimisation
+### Root Finding
 
 A comprehensive set of root-finding algorithms over the real line, both with derivatives and derivative free.
 
-Also function minimisation via Brent's Method.
+### Optimization
+
+Minimization of cost functions via Brent's method and differential evolution.
 
 ### Polynomials and Rational Functions
 
@@ -50,11 +78,17 @@ Tools for manipulating polynomials and for efficient evaluation of rationals or
 
 ### Interpolation
 
-Function interpolation via barycentric rational interpolation, compactly supported quadratic, cubic, and quintic B-splines, the Chebyshev transform, trigonometric polynomials, Makima, pchip, cubic Hermite splines, and bilinear interpolation.
+Function interpolation via barycentric rational interpolation,
+compactly supported quadratic, cubic, and quintic B-splines,
+the Chebyshev transform, trigonometric polynomials, Makima,
+pchip, cubic Hermite splines, and bilinear interpolation.
 
 ### Numerical Integration and Differentiation
 
-A reasonably comprehensive set of routines for integration (trapezoidal, Gauss-Legendre, Gauss-Kronrod, Gauss-Chebyshev, double-exponential, and Monte-Carlo) and differentiation (Chebyshev transform, finite difference, the complex step derivative, and forward-mode automatic differentiation).
+A reasonably comprehensive set of routines for integration
+(trapezoidal, Gauss-Legendre, Gauss-Kronrod, Gauss-Chebyshev, double-exponential, and Monte-Carlo)
+and differentiation (Chebyshev transform, finite difference, the complex step derivative,
+and forward-mode automatic differentiation).
 
 The integration routines are usable for functions returning complex results - and hence can be used for computation of  contour integrals.
 
@@ -66,25 +100,20 @@ The full documentation is available on [boost.org](http://www.boost.org/doc/libs
 
 ### Standalone Mode
 
-Defining BOOST_MATH_STANDALONE allows Boost.Math to be used without any Boost dependencies. Some functionality is reduced in this mode. A static_assert message will alert you if a particular feature has been disabled by standalone mode.
+Defining BOOST_MATH_STANDALONE allows Boost.Math to be used without any Boost dependencies.
+Some functionality is reduced in this mode. A static_assert message will alert you
+if a particular feature has been disabled by standalone mode. Standalone mode is not designed to 
+be used with the rest of boost, and may result in compiler errors.
 
 ## Supported Compilers ##
 
-The following compilers are tested with the CI system, and are known to work. Starting with Boost 1.76 (April 2021 Release) a compiler that is fully compliant with C++11 is required to use Boost.Math.
+The following compilers are tested with the CI system, and are known to work.
+Currently a compiler that is fully compliant with C++14 is required to use Boost.Math.
 
 * g++ 5 or later
 * clang++ 5 or later
 * Visual Studio 2015 (14.0) or later
 
-## Build Status ##
-
-|                  |  Master  |   Develop   |
-|------------------|----------|-------------|
-| Github Actions | [![Build Status](https://github.com/boostorg/math/workflows/CI/badge.svg?branch=master)](https://github.com/boostorg/math/actions) | [![Build Status](https://github.com/boostorg/math/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/math/actions) |
-|Drone | [![Build Status](https://drone.cpp.al/api/badges/boostorg/math/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/math) | [![Build Status](https://drone.cpp.al/api/badges/boostorg/math/status.svg)](https://drone.cpp.al/boostorg/math) |
-
-
-
 ## Support, bugs and feature requests ##
 
 Bugs and feature requests can be reported through the [GitHub issue tracker](https://github.com/boostorg/math/issues)
diff --git a/contrib/restricted/boost/math/include/boost/math/policies/policy.hpp b/contrib/restricted/boost/math/include/boost/math/policies/policy.hpp
index 6daebaa64f..eb09682e32 100644
--- a/contrib/restricted/boost/math/include/boost/math/policies/policy.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/policies/policy.hpp
@@ -35,7 +35,7 @@ namespace policies{
 //
 // Special cases for exceptions disabled first:
 //
-#ifdef BOOST_NO_EXCEPTIONS
+#ifdef BOOST_MATH_NO_EXCEPTIONS
 #  ifndef BOOST_MATH_DOMAIN_ERROR_POLICY
 #    define BOOST_MATH_DOMAIN_ERROR_POLICY errno_on_error
 #  endif
diff --git a/contrib/restricted/boost/math/include/boost/math/special_functions/detail/fp_traits.hpp b/contrib/restricted/boost/math/include/boost/math/special_functions/detail/fp_traits.hpp
index 975052b52e..2947a32a21 100644
--- a/contrib/restricted/boost/math/include/boost/math/special_functions/detail/fp_traits.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/special_functions/detail/fp_traits.hpp
@@ -34,16 +34,6 @@ With these techniques, the code could be simplified.
 #define BOOST_MATH_ENDIAN_BIG_BYTE BOOST_ENDIAN_BIG_BYTE
 #define BOOST_MATH_ENDIAN_LITTLE_BYTE BOOST_ENDIAN_LITTLE_BYTE
 
-#elif (__cplusplus >= 202002L || _MSVC_LANG >= 202002L)
-
-#if __has_include(<bit>)
-#include <bit>
-#define BOOST_MATH_ENDIAN_BIG_BYTE (std::endian::native == std::endian::big)
-#define BOOST_MATH_ENDIAN_LITTLE_BYTE (std::endian::native == std::endian::little)
-#else
-#error Missing <bit> header. Please disable standalone mode, and file an issue at https://github.com/boostorg/math
-#endif
-
 #elif defined(_WIN32)
 
 #define BOOST_MATH_ENDIAN_BIG_BYTE 0
diff --git a/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp b/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp
index 7b99651402..3e5d6a7625 100644
--- a/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/special_functions/math_fwd.hpp
@@ -1087,10 +1087,10 @@ namespace boost
 
    // pow:
    template <int N, typename T, class Policy>
-   BOOST_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base, const Policy& policy);
+   BOOST_MATH_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base, const Policy& policy);
 
    template <int N, typename T>
-   BOOST_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base);
+   BOOST_MATH_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base);
 
    // next:
    template <class T, class U, class Policy>
diff --git a/contrib/restricted/boost/math/include/boost/math/tools/config.hpp b/contrib/restricted/boost/math/include/boost/math/tools/config.hpp
index 584cbd5485..110edc06b7 100644
--- a/contrib/restricted/boost/math/include/boost/math/tools/config.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/tools/config.hpp
@@ -16,20 +16,73 @@
 // Minimum language standard transition
 #ifdef _MSVC_LANG
 #  if _MSVC_LANG < 201402L
-#    pragma warning("The minimum language standard to use Boost.Math will be C++14 starting in July 2023 (Boost 1.82 release)");
+#    pragma message("Boost.Math requires C++14");
+#  endif
+#  if _MSC_VER == 1900
+#    pragma message("MSVC 14.0 has broken C++14 constexpr support. Support for this compiler will be removed in Boost 1.86")
 #  endif
 #else
 #  if __cplusplus < 201402L
-#    warning "The minimum language standard to use Boost.Math will be C++14 starting in July 2023 (Boost 1.82 release)"
+#    warning "Boost.Math requires C++14"
 #  endif
 #endif
 
 #ifndef BOOST_MATH_STANDALONE
 #include <boost/config.hpp>
 
+
+// The following are all defined as standalone macros as well
+// If Boost.Config is available just use those definitions because they are more fine-grained
+
+// Could be defined in TR1
+#ifndef BOOST_MATH_PREVENT_MACRO_SUBSTITUTION
+#  define BOOST_MATH_PREVENT_MACRO_SUBSTITUTION BOOST_PREVENT_MACRO_SUBSTITUTION
+#endif
+
+#define BOOST_MATH_CXX14_CONSTEXPR BOOST_CXX14_CONSTEXPR
+#ifdef BOOST_NO_CXX14_CONSTEXPR
+#  define BOOST_MATH_NO_CXX14_CONSTEXPR
+#endif
+
+#define BOOST_MATH_IF_CONSTEXPR BOOST_IF_CONSTEXPR
+#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
+#  define BOOST_MATH_NO_CXX17_IF_CONSTEXPR
+#endif
+
+#ifdef BOOST_NO_CXX17_HDR_EXECUTION
+#  define BOOST_MATH_NO_CXX17_HDR_EXECUTION
+#endif
+
+#ifdef BOOST_HAS_THREADS
+#  define BOOST_MATH_HAS_THREADS
+#endif
+#ifdef BOOST_DISABLE_THREADS
+#  define BOOST_MATH_DISABLE_THREADS
+#endif
+#ifdef BOOST_NO_CXX11_THREAD_LOCAL
+#  define BOOST_MATH_NO_CXX11_THREAD_LOCAL
+#endif
+
+#ifdef BOOST_NO_EXCEPTIONS
+#  define BOOST_MATH_NO_EXCEPTIONS
+#endif
+
+#ifdef BOOST_NO_TYPEID
+#  define BOOST_MATH_NO_TYPEID
+#endif
+#ifdef BOOST_NO_RTTI
+#  define BOOST_MATH_NO_RTTI
+#endif
+
+#define BOOST_MATH_NOINLINE BOOST_NOINLINE
+#define BOOST_MATH_FORCEINLINE BOOST_FORCEINLINE
+
+#define BOOST_MATH_JOIN(X, Y) BOOST_JOIN(X, Y)
+#define BOOST_MATH_STRINGIZE(X) BOOST_STRINGIZE(X)
+
 #else // Things from boost/config that are required, and easy to replicate
 
-#define BOOST_PREVENT_MACRO_SUBSTITUTION
+#define BOOST_MATH_PREVENT_MACRO_SUBSTITUTION
 #define BOOST_MATH_NO_REAL_CONCEPT_TESTS
 #define BOOST_MATH_NO_DISTRIBUTION_CONCEPT_TESTS
 #define BOOST_MATH_NO_LEXICAL_CAST
@@ -38,59 +91,56 @@
 #define BOOST_MATH_NO_MP_TESTS
 
 #if (__cplusplus > 201400L || _MSVC_LANG > 201400L)
-#define BOOST_CXX14_CONSTEXPR constexpr
+#define BOOST_MATH_CXX14_CONSTEXPR constexpr
 #else
-#define BOOST_CXX14_CONSTEXPR
-#define BOOST_NO_CXX14_CONSTEXPR
-#endif // BOOST_CXX14_CONSTEXPR
+#define BOOST_MATH_CXX14_CONSTEXPR
+#define BOOST_MATH_NO_CXX14_CONSTEXPR
+#endif // BOOST_MATH_CXX14_CONSTEXPR
 
 #if (__cplusplus > 201700L || _MSVC_LANG > 201700L)
-#define BOOST_IF_CONSTEXPR if constexpr
+#define BOOST_MATH_IF_CONSTEXPR if constexpr
 
 // Clang on mac provides the execution header with none of the functionality. TODO: Check back on this
 // https://en.cppreference.com/w/cpp/compiler_support "Standardization of Parallelism TS"
-#if !__has_include(<execution>) || (defined(__APPLE__) && defined(__clang__))
-#define BOOST_NO_CXX17_HDR_EXECUTION
-#endif
+#  if !__has_include(<execution>) || (defined(__APPLE__) && defined(__clang__))
+#  define BOOST_MATH_NO_CXX17_HDR_EXECUTION
+#  endif
 #else
-#define BOOST_IF_CONSTEXPR if
-#define BOOST_NO_CXX17_IF_CONSTEXPR
-#define BOOST_NO_CXX17_HDR_EXECUTION
+#  define BOOST_MATH_IF_CONSTEXPR if
+#  define BOOST_MATH_NO_CXX17_IF_CONSTEXPR
+#  define BOOST_MATH_NO_CXX17_HDR_EXECUTION
 #endif
 
 #if __cpp_lib_gcd_lcm >= 201606L
 #define BOOST_MATH_HAS_CXX17_NUMERIC
 #endif
 
-#define BOOST_JOIN(X, Y) BOOST_DO_JOIN(X, Y)
-#define BOOST_DO_JOIN(X, Y) BOOST_DO_JOIN2(X,Y)
-#define BOOST_DO_JOIN2(X, Y) X##Y
+#define BOOST_MATH_JOIN(X, Y) BOOST_MATH_DO_JOIN(X, Y)
+#define BOOST_MATH_DO_JOIN(X, Y) BOOST_MATH_DO_JOIN2(X,Y)
+#define BOOST_MATH_DO_JOIN2(X, Y) X##Y
 
-#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
-#define BOOST_DO_STRINGIZE(X) #X
+#define BOOST_MATH_STRINGIZE(X) BOOST_MATH_DO_STRINGIZE(X)
+#define BOOST_MATH_DO_STRINGIZE(X) #X
 
-#ifdef BOOST_DISABLE_THREADS // No threads, do nothing
+#ifdef BOOST_MATH_DISABLE_THREADS // No threads, do nothing
 // Detect thread support via STL implementation
 #elif defined(__has_include)
 #  if !__has_include(<thread>) || !__has_include(<mutex>) || !__has_include(<future>) || !__has_include(<atomic>)
-#     define BOOST_DISABLE_THREADS
+#     define BOOST_MATH_DISABLE_THREADS
 #  else
-#     define BOOST_HAS_THREADS
+#     define BOOST_MATH_HAS_THREADS
 #  endif 
 #else
-#  define BOOST_HAS_THREADS // The default assumption is that the machine has threads
+#  define BOOST_MATH_HAS_THREADS // The default assumption is that the machine has threads
 #endif // Thread Support
 
-#ifdef BOOST_DISABLE_THREADS
-#  define BOOST_NO_CXX11_HDR_ATOMIC
-#  define BOOST_NO_CXX11_HDR_FUTURE
-#  define BOOST_NO_CXX11_HDR_THREAD
-#  define BOOST_NO_CXX11_THREAD_LOCAL
-#endif // BOOST_DISABLE_THREADS
+#ifdef BOOST_MATH_DISABLE_THREADS
+#  define BOOST_MATH_NO_CXX11_THREAD_LOCAL
+#endif // BOOST_MATH_DISABLE_THREADS
 
 #ifdef __GNUC__
-#  if !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
-#     define BOOST_NO_EXCEPTIONS
+#  if !defined(__EXCEPTIONS) && !defined(BOOST_MATH_NO_EXCEPTIONS)
+#     define BOOST_MATH_NO_EXCEPTIONS
 #  endif
    //
    // Make sure we have some std lib headers included so we can detect __GXX_RTTI:
@@ -98,43 +148,43 @@
 #  include <algorithm>  // for min and max
 #  include <limits>
 #  ifndef __GXX_RTTI
-#     ifndef BOOST_NO_TYPEID
-#        define BOOST_NO_TYPEID
+#     ifndef BOOST_MATH_NO_TYPEID
+#        define BOOST_MATH_NO_TYPEID
 #     endif
-#     ifndef BOOST_NO_RTTI
-#        define BOOST_NO_RTTI
+#     ifndef BOOST_MATH_NO_RTTI
+#        define BOOST_MATH_NO_RTTI
 #     endif
 #  endif
 #endif
 
-#if !defined(BOOST_NOINLINE)
+#if !defined(BOOST_MATH_NOINLINE)
 #  if defined(_MSC_VER)
-#    define BOOST_NOINLINE __declspec(noinline)
+#    define BOOST_MATH_NOINLINE __declspec(noinline)
 #  elif defined(__GNUC__) && __GNUC__ > 3
      // Clang also defines __GNUC__ (as 4)
 #    if defined(__CUDACC__)
        // nvcc doesn't always parse __noinline__,
        // see: https://svn.boost.org/trac/boost/ticket/9392
-#      define BOOST_NOINLINE __attribute__ ((noinline))
+#      define BOOST_MATH_NOINLINE __attribute__ ((noinline))
 #    elif defined(__HIP__)
        // See https://github.com/boostorg/config/issues/392
-#      define BOOST_NOINLINE __attribute__ ((noinline))
+#      define BOOST_MATH_NOINLINE __attribute__ ((noinline))
 #    else
-#      define BOOST_NOINLINE __attribute__ ((__noinline__))
+#      define BOOST_MATH_NOINLINE __attribute__ ((__noinline__))
 #    endif
 #  else
-#    define BOOST_NOINLINE
+#    define BOOST_MATH_NOINLINE
 #  endif
 #endif
 
-#if !defined(BOOST_FORCEINLINE)
+#if !defined(BOOST_MATH_FORCEINLINE)
 #  if defined(_MSC_VER)
-#    define BOOST_FORCEINLINE __forceinline
+#    define BOOST_MATH_FORCEINLINE __forceinline
 #  elif defined(__GNUC__) && __GNUC__ > 3
      // Clang also defines __GNUC__ (as 4)
-#    define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
+#    define BOOST_MATH_FORCEINLINE inline __attribute__ ((__always_inline__))
 #  else
-#    define BOOST_FORCEINLINE inline
+#    define BOOST_MATH_FORCEINLINE inline
 #  endif
 #endif
 
@@ -142,7 +192,7 @@
 
 // Support compilers with P0024R2 implemented without linking TBB
 // https://en.cppreference.com/w/cpp/compiler_support
-#if !defined(BOOST_NO_CXX17_HDR_EXECUTION) && defined(BOOST_HAS_THREADS)
+#if !defined(BOOST_MATH_NO_CXX17_HDR_EXECUTION) && defined(BOOST_MATH_HAS_THREADS)
 #  define BOOST_MATH_EXEC_COMPATIBLE
 #endif
 
@@ -461,13 +511,13 @@ namespace tools
 {
 
 template <class T>
-inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c) BOOST_MATH_NOEXCEPT(T)
+inline T max BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c) BOOST_MATH_NOEXCEPT(T)
 {
    return (std::max)((std::max)(a, b), c);
 }
 
 template <class T>
-inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) BOOST_MATH_NOEXCEPT(T)
+inline T max BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) BOOST_MATH_NOEXCEPT(T)
 {
    return (std::max)((std::max)(a, b), (std::max)(c, d));
 }
@@ -565,7 +615,7 @@ namespace boost{ namespace math{
 //
 // Thread local storage:
 //
-#ifndef BOOST_DISABLE_THREADS
+#ifndef BOOST_MATH_DISABLE_THREADS
 #  define BOOST_MATH_THREAD_LOCAL thread_local
 #else
 #  define BOOST_MATH_THREAD_LOCAL 
@@ -583,7 +633,7 @@ namespace boost{ namespace math{
 //
 // Can we have constexpr tables?
 //
-#if (!defined(BOOST_NO_CXX14_CONSTEXPR)) || (defined(_MSC_VER) && _MSC_VER >= 1910)
+#if (!defined(BOOST_MATH_NO_CXX14_CONSTEXPR)) || (defined(_MSC_VER) && _MSC_VER >= 1910)
 #define BOOST_MATH_HAVE_CONSTEXPR_TABLES
 #define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION constexpr
 #else
diff --git a/contrib/restricted/boost/math/include/boost/math/tools/mp.hpp b/contrib/restricted/boost/math/include/boost/math/tools/mp.hpp
index 3100a0bb67..55aac1b092 100644
--- a/contrib/restricted/boost/math/include/boost/math/tools/mp.hpp
+++ b/contrib/restricted/boost/math/include/boost/math/tools/mp.hpp
@@ -168,11 +168,11 @@ struct mp_at_c<L<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T...>, 1
 };
 }
 
-template<typename L, std::size_t I>
-using mp_at_c = typename detail::mp_at_c<L, I>::type;
+template<typename L, std::size_t Index>
+using mp_at_c = typename detail::mp_at_c<L, Index>::type;
 
-template<typename L, typename I>
-using mp_at = typename detail::mp_at_c<L, I::value>::type;
+template<typename L, typename Index>
+using mp_at = typename detail::mp_at_c<L, Index::value>::type;
 
 // Back
 template<typename L> 
@@ -339,8 +339,8 @@ using mp_remove_if_q = mp_remove_if<L, Q::template fn>;
 // Index sequence
 // Use C++14 index sequence if available
 #if defined(__cpp_lib_integer_sequence) && (__cpp_lib_integer_sequence >= 201304)
-template<std::size_t... I>
-using index_sequence = std::index_sequence<I...>;
+template<std::size_t... Index>
+using index_sequence = std::index_sequence<Index...>;
 
 template<std::size_t N>
 using make_index_sequence = std::make_index_sequence<N>;
@@ -350,11 +350,11 @@ using index_sequence_for = std::index_sequence_for<T...>;
 
 #else
 
-template<typename T, T... I>
+template<typename T, T... Index>
 struct integer_sequence {};
 
-template<std::size_t... I>
-using index_sequence = integer_sequence<std::size_t, I...>;
+template<std::size_t... Index>
+using index_sequence = integer_sequence<std::size_t, Index...>;
 
 namespace detail {
 
@@ -385,10 +385,10 @@ struct iseq_identity
 template<typename T1, typename T2>
 struct append_integer_sequence {};
 
-template<typename T, T... I, T... J>
-struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+template<typename T, T... Index, T... J>
+struct append_integer_sequence<integer_sequence<T, Index...>, integer_sequence<T, J...>>
 {
-    using type = integer_sequence<T, I..., (J + sizeof...(I))...>;
+    using type = integer_sequence<T, Index..., (J + sizeof...(Index))...>;
 };
 
 template<typename T, T N>
diff --git a/contrib/restricted/boost/math/ya.make b/contrib/restricted/boost/math/ya.make
index 660c3ca286..b4bef35c73 100644
--- a/contrib/restricted/boost/math/ya.make
+++ b/contrib/restricted/boost/math/ya.make
@@ -6,9 +6,9 @@ LICENSE(BSL-1.0)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.84.0)
+VERSION(1.85.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/math/archive/boost-1.84.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/math/archive/boost-1.85.0.tar.gz)
 
 PEERDIR(
     contrib/restricted/boost/assert