Complete CI test with standalone mode (#680)

2025-05-11 21:33:52 +00:00 · 2022-01-14 18:12:22 +02:00 · 2022-01-14 18:12:22 +02:00 · e1601f129a
commit e1601f129a
parent 3019900cb7
327 changed files with 1005 additions and 701 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -18,7 +18,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        compiler: [ g++-9, g++-10, g++-11, clang++-10 ]
+        compiler: [ g++-9, g++-11, clang++-10 ]
        standard: [ c++11, c++14, c++17, c++2a ]
        suite: [ float128_tests, special_fun, distribution_tests, misc, quadrature, mp, interpolators, autodiff, ../example//examples, ../tools ]
    steps:
@ -47,7 +47,7 @@ jobs:
        if: steps.retry1.outcome=='failure'
        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
      - name: Install packages
-        run: sudo apt install g++-9 g++-10 g++-11 clang-9 clang-10 libgmp-dev libmpfr-dev libfftw3-dev
+        run: sudo apt install g++-9 g++-11 clang-9 clang-10 libgmp-dev libmpfr-dev libfftw3-dev
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
@ -232,7 +232,7 @@ jobs:
      - name: Test
        run: ..\..\..\b2 --hash %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES ${{ matrix.suite }}
        working-directory: ../boost-root/libs/math/test
-  standalone-gcc:
+  standalone-compile-tests-gcc:
      runs-on: ubuntu-20.04
      strategy:
        fail-fast: false
@ -275,7 +275,7 @@ jobs:
        - name: Run Compile Tests
          run: make -j$((`nproc`+1))
          working-directory: ../boost-root/libs/math
-  standalone-clang:
+  standalone-compile-tests-clang:
      runs-on: ubuntu-20.04
      strategy:
        fail-fast: false
@ -318,3 +318,67 @@ jobs:
        - name: Run Compile Tests
          run: make -j$((`nproc`+1))
          working-directory: ../boost-root/libs/math
+  standalone-gcc:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [ g++-10 ]
+        standard: [ c++11, c++14, c++17, c++2a ]
+        suite: [ float128_tests, special_fun, distribution_tests, misc, quadrature, interpolators, autodiff, ../example//examples, ../tools ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE];[standalone];[STANDALONE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Set TOOLSET
+        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+      - name: Add repository
+        continue-on-error: true
+        id: addrepo
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo
+        continue-on-error: true
+        id: retry1
+        if: steps.addrepo.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo 2
+        continue-on-error: true
+        id: retry2
+        if: steps.retry1.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Install packages
+        run: sudo apt install g++-10 libgmp-dev libmpfr-dev libfftw3-dev
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/math
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py math
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Generate user config
+        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: ./config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=$TOOLSET ${{ matrix.suite }} define=CI_SUPPRESS_KNOWN_ISSUES define=SLOW_COMPILER define=BOOST_MATH_STANDALONE define=BOOST_MP_STANDALONE
+        working-directory: ../boost-root/libs/math/test
--- a/.gitignore
+++ b/.gitignore
@ -10,8 +10,9 @@ test/cuda
 **/.temps/*
 build/*
 .vscode/*
+*.svg
+tools/bin/**
 .idea/*
-tools/bin/*

 # CMake Related Options
 *.a
--- a/config/Jamfile.v2
+++ b/config/Jamfile.v2
@ -34,6 +34,7 @@ obj has_mpfr : has_mpfr.cpp :
 obj has_gmp : has_gmp.cpp :
      <include>$(gmp_path) <include>$(gmp_path)/mpfr <include>$(gmp_path)/gmpfrxx ;
 obj is_ci_sanitizer_run : is_ci_sanitizer_run.cpp ;
+obj is_ci_standalone_run : is_ci_standalone_run.cpp ;

 explicit has_long_double_support ;
 explicit has_mpfr_class ;
@ -48,4 +49,4 @@ explicit has_intel_quad ;
 explicit has_128bit_floatmax_t ;
 explicit has_fftw3 ;
 explicit is_ci_sanitizer_run ;
-
+explicit is_ci_standalone_run ;
--- a/config/is_ci_standalone_run.cpp
+++ b/config/is_ci_standalone_run.cpp
@ -0,0 +1,13 @@
+//  Copyright Matt Borland 2022.
+//  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_MATH_STANDALONE
+#  error "Standalone is NOT in effect".
+#endif
+
+int main()
+{
+   return 0;
+}
--- a/doc/background/special_tut.qbk
+++ b/doc/background/special_tut.qbk
@ -196,7 +196,7 @@ for each code branch our implementation may take.  To slot these in nicely with
 tabulate these like this:

    // function values calculated on http://functions.wolfram.com/
-    static const boost::array<boost::array<T, 3>, 10> my_special_data = {{
+    static const std::array<std::array<T, 3>, 10> my_special_data = {{
        {{ SC_(0), SC_(0), SC_(1) }},
        {{ SC_(0), SC_(1), SC_(1.26606587775200833559824462521471753760767031135496220680814) }},
        /* More values here... */
@ -254,7 +254,7 @@ definition for the SC_ macro:
   #include <boost/test/tools/floating_point_comparison.hpp>
   // Our function to test:
   #include <boost/math/special_functions/my_special.hpp>
-   // We need boost::array for our test data, plus a few headers from
+   // We need std::array for our test data, plus a few headers from
   // libs/math/test that contain our testing machinery:
   #include <boost/array.hpp>
   #include "functor.hpp"
--- a/doc/html/math_toolkit/high_precision/use_multiprecision.html
+++ b/doc/html/math_toolkit/high_precision/use_multiprecision.html
@ -135,7 +135,7 @@
      </p>
 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">fp_type</span> <span class="special">=</span> <span class="string">"double"</span><span class="special">;</span>

-<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Generating an `std::array` or `boost::array` for floating-point type: "</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Generating an `std::array` or `std::array` for floating-point type: "</span>
  <span class="special">&lt;&lt;</span> <span class="identifier">fp_type</span> <span class="special">&lt;&lt;</span> <span class="string">". "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 </pre>
 <p>
--- a/doc/html/math_toolkit/internals/error_test.html
+++ b/doc/html/math_toolkit/internals/error_test.html
@ -144,7 +144,7 @@
 <p>
        Parameter <span class="emphasis"><em>a</em></span> is a matrix of test data: and must be a
        standard library Sequence type, that contains another Sequence type: typically
-        it will be a two dimensional instance of <code class="literal">boost::array</code>.
+        it will be a two dimensional instance of <code class="literal">std::array</code>.
        Each row of <span class="emphasis"><em>a</em></span> should contain all the parameters that
        are passed to the function under test as well as the expected result.
      </p>
--- a/doc/html/math_toolkit/special_tut/special_tut_test.html
+++ b/doc/html/math_toolkit/special_tut/special_tut_test.html
@ -229,7 +229,7 @@
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">test</span><span class="special">/</span><span class="identifier">tools</span><span class="special">/</span><span class="identifier">floating_point_comparison</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="comment">// Our function to test:</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">my_special</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-<span class="comment">// We need boost::array for our test data, plus a few headers from</span>
+<span class="comment">// We need std::array for our test data, plus a few headers from</span>
 <span class="comment">// libs/math/test that contain our testing machinery:</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="string">"functor.hpp"</span>
--- a/doc/internals/polynomial.qbk
+++ b/doc/internals/polynomial.qbk
@ -25,10 +25,10 @@
      polynomial(I first, I last);
      template <class U>
      explicit polynomial(const U& point, 
-            typename boost::enable_if<std::is_convertible<U, T> >::type* = 0);
+            typename std::enable_if<std::is_convertible<U, T> >::type* = nullptr);
      template <class Range>
      explicit polynomial(const Range& r, 
-            typename boost::enable_if<boost::math::tools::detail::is_const_iterable<Range> >::type* = 0); // C++14
+            typename std::enable_if<boost::math::tools::detail::is_const_iterable<Range> >::type* = nullptr); // C++14
      polynomial(std::initializer_list<T> l); // C++11

      polynomial(std::vector<T>&& p);
--- a/doc/internals/recurrence.qbk
+++ b/doc/internals/recurrence.qbk
@ -132,7 +132,7 @@ Returns F[sub n - number_of_steps].
   template <class Recurrence>
   struct forward_recurrence_iterator
   {
-      typedef typename boost::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;
+      typedef typename std::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;

      forward_recurrence_iterator(const Recurrence& r, value_type f_n_minus_1, value_type f_n);
      forward_recurrence_iterator(const Recurrence& r, value_type f_n);
@ -146,7 +146,7 @@ only one value is provided, then the second is computed by using the recurrence
   template <class Recurrence>
   struct backward_recurrence_iterator
   {
-      typedef typename boost::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;
+      typedef typename std::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;

      backward_recurrence_iterator(const Recurrence& r, value_type f_n_plus_1, value_type f_n);
      backward_recurrence_iterator(const Recurrence& r, value_type f_n);
--- a/doc/internals/relative_error.qbk
+++ b/doc/internals/relative_error.qbk
@ -62,7 +62,7 @@ dimensional array passed to function /test/, roughly that's
 Parameter /a/ is a matrix of test data: and must be a standard library Sequence type,
 that contains another Sequence type:
 typically it will be a two dimensional instance of 
-[^boost::array].  Each row
+[^std::array].  Each row
 of /a/ should contain all the parameters that are passed to the function 
 under test as well as the expected result.

@ -87,7 +87,7 @@ two-dimensional matrix of test data, each row is one test case, and contains
 three elements: the input value, and the expected results for the `tgamma` and
 `lgamma` functions respectively.

-   static const boost::array<boost::array<TestType, 3>, NumberOfTests> 
+   static const std::array<std::array<TestType, 3>, NumberOfTests> 
      factorials = {
         /* big array of test data goes here */
      };
--- a/doc/internals/test_data.qbk
+++ b/doc/internals/test_data.qbk
@ -268,7 +268,7 @@ There's just one final step now, and that's to write the test data to file:
 The format of the test data looks something like:

   #define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
-      static const boost::array<boost::array<T, 3>, 1830>
+      static const std::array<std::array<T, 3>, 1830>
      beta_med_data = {
         SC_(0.4883005917072296142578125),
         SC_(0.4883005917072296142578125),
--- a/example/Jamfile.v2
+++ b/example/Jamfile.v2
@ -43,9 +43,9 @@ project
    ;

 test-suite examples :
-   [ run bessel_zeros_example_1.cpp : : : <exception-handling>off:<build>no  ]
+   [ run bessel_zeros_example_1.cpp : : : [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] <exception-handling>off:<build>no ]
   [ run bessel_zeros_interator_example.cpp : : : <exception-handling>off:<build>no  ]
-   [ run neumann_zeros_example_1.cpp : : : <exception-handling>off:<build>no  ]
+   [ run neumann_zeros_example_1.cpp : : : [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] <exception-handling>off:<build>no  ]

   [ run test_cpp_float_close_fraction.cpp ../../test/build//boost_unit_test_framework/<link>static : : : <exception-handling>off:<build>no  ]
   [ run binomial_coinflip_example.cpp : : : <exception-handling>off:<build>no  ]
@ -145,8 +145,8 @@ test-suite examples :
   [ run autodiff_black_scholes_brief.cpp : : : [ requires cxx11_inline_namespaces ] ]
   [ run autodiff_black_scholes.cpp : : : [ requires cxx11_inline_namespaces ] ]
   [ run autodiff_fourth_power.cpp : : : [ requires cxx11_inline_namespaces ] ]
-   [ run autodiff_mixed_partials.cpp : : : [ requires cxx11_inline_namespaces ] ]
-   [ run autodiff_multiprecision.cpp : : : [ requires cxx11_inline_namespaces ] ]
+   [ run autodiff_mixed_partials.cpp : : : [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] [ requires cxx11_inline_namespaces ] ]
+   [ run autodiff_multiprecision.cpp : : : [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] [ requires cxx11_inline_namespaces ] ]
   [ run ooura_fourier_integrals_example.cpp : : : [ requires cxx11_hdr_mutex cxx11_lambdas cxx11_inline_namespaces cxx11_auto_declarations ] ]
   [ run ooura_fourier_integrals_cosine_example.cpp : : : [ requires cxx11_hdr_mutex cxx11_inline_namespaces cxx11_auto_declarations cxx17_std_apply ] ]
   [ run ooura_fourier_integrals_multiprecision_example.cpp : : : [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_hdr_mutex cxx11_inline_namespaces cxx11_auto_declarations cxx17_std_apply ] ]
--- a/example/fft_sines_table.cpp
+++ b/example/fft_sines_table.cpp
@ -131,7 +131,7 @@ and a C++11 lambda function combined with `std::for_each()`.

 std::string fp_type = "double";

-std::cout << "Generating an `std::array` or `boost::array` for floating-point type: "
+std::cout << "Generating an `std::array` or `std::array` for floating-point type: "
  << fp_type << ". " << std::endl;

 /*`By default, output would only show the standard 6 decimal digits,
--- a/example/inverse_gaussian_example.cpp
+++ b/example/inverse_gaussian_example.cpp
@ -43,7 +43,7 @@ First we need some includes to access the normal distribution
 using boost::math::normal; // typedef provides default type is double.

 #include <boost/array.hpp>
-using boost::array;
+using std::array;

 #include <iostream>
  using std::cout; using std::endl; using std::left; using std::showpoint; using std::noshowpoint;
--- a/example/polynomial_arithmetic.cpp
+++ b/example/polynomial_arithmetic.cpp
@ -118,7 +118,7 @@ in descending order of degree, Boost.Math stores in [*ascending order of degree]
  Read/write for humans:    3x^3 - 4x^2 - 6x + 10
  Boost polynomial storage: [ 10, -6, -4, 3 ]
 */
-  boost::array<double, 4> const d3a = {{10, -6, -4, 3}};
+  std::array<double, 4> const d3a = {{10, -6, -4, 3}};
  polynomial<double> const a(d3a.begin(), d3a.end());

  // With C++11 and later, you can also use initializer_list construction.
--- a/include/boost/math/interpolators/barycentric_rational.hpp
+++ b/include/boost/math/interpolators/barycentric_rational.hpp
@ -40,7 +40,7 @@ public:
    barycentric_rational(std::vector<Real>&& x, std::vector<Real>&& y, size_t approximation_order = 3);

    template <class InputIterator1, class InputIterator2>
-    barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3, typename std::enable_if<!std::is_integral<InputIterator2>::value>::type* = 0);
+    barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3, typename std::enable_if<!std::is_integral<InputIterator2>::value>::type* = nullptr);

    Real operator()(Real x) const;

--- a/include/boost/math/special_functions/detail/unchecked_factorial.hpp
+++ b/include/boost/math/special_functions/detail/unchecked_factorial.hpp
@ -979,6 +979,8 @@ inline T unchecked_factorial(unsigned i)
   return unchecked_factorial_imp<T>(i, tag_type());
 }

+#endif // BOOST_NO_LEXICAL_CAST
+
 #ifdef BOOST_MATH_USE_FLOAT128
 #define BOOST_MATH_DETAIL_FLOAT128_MAX_FACTORIAL : std::numeric_limits<T>::digits == 113 ? max_factorial<BOOST_MATH_FLOAT128_TYPE>::value
 #else
@ -998,22 +1000,6 @@ struct max_factorial

 #undef BOOST_MATH_DETAIL_FLOAT128_MAX_FACTORIAL

-#else // BOOST_MATH_NO_LEXICAL_CAST
-
-template <class T>
-inline T unchecked_factorial(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(T))
-{
-   return 1;
-}
-
-template <class T>
-struct max_factorial
-{
-   static constexpr unsigned value = 0;
-};
-
-#endif
-
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 template <class T>
 const unsigned max_factorial<T>::value;
--- a/include/boost/math/special_functions/hypergeometric_pFq.hpp
+++ b/include/boost/math/special_functions/hypergeometric_pFq.hpp
@ -9,6 +9,7 @@
 #define BOOST_MATH_HYPERGEOMETRIC_PFQ_HPP

 #include <boost/math/special_functions/detail/hypergeometric_pFq_checked_series.hpp>
+#include <boost/math/tools/throw_exception.hpp>
 #include <chrono>
 #include <initializer_list>

@ -29,9 +30,9 @@ namespace boost {
            bool operator()(std::uintmax_t iter)const
            {
               if (iter > max_iter)
-                  boost::throw_exception(boost::math::detail::pFq_termination_exception("pFq exceeded maximum permitted iterations."));
+                  BOOST_MATH_THROW_EXCEPTION(boost::math::detail::pFq_termination_exception("pFq exceeded maximum permitted iterations."));
               if (std::chrono::duration<double>(std::chrono::system_clock::now() - start_time).count() > max_time)
-                  boost::throw_exception(boost::math::detail::pFq_termination_exception("pFq exceeded maximum permitted evaluation time."));
+                  BOOST_MATH_THROW_EXCEPTION(boost::math::detail::pFq_termination_exception("pFq exceeded maximum permitted evaluation time."));
               return false;
            }

--- a/include/boost/math/tools/big_constant.hpp
+++ b/include/boost/math/tools/big_constant.hpp
@ -10,6 +10,7 @@
 #include <boost/math/tools/config.hpp>
 #include <boost/math/tools/lexical_cast.hpp>

+#include <cstdlib>
 #include <type_traits>
 #include <limits>

@ -55,6 +56,12 @@ inline T make_big_value(largest_float, const char* s, std::false_type const&, st
 {
   return boost::lexical_cast<T>(s);
 }
+#else
+template <typename T>
+inline T make_big_value(largest_float, const char* s, std::false_type const&, std::false_type const&)
+{
+   static_assert(sizeof(T) == 0, "Type is unsupported in standalone mode. Please disable and try again.");
+}
 #endif
 template <class T>
 inline constexpr T make_big_value(largest_float, const char* s, std::false_type const&, std::true_type const&) BOOST_MATH_NOEXCEPT(T)
--- a/include/boost/math/tools/config.hpp
+++ b/include/boost/math/tools/config.hpp
@ -24,6 +24,9 @@
 #define BOOST_MATH_NO_LEXICAL_CAST
 #define TEST_STD

+// Since Boost.Multiprecision is in active development some tests do not fully cooperate yet.
+#define BOOST_MATH_NO_MP_TESTS
+
 #if (__cplusplus > 201400L || _MSVC_LANG > 201400L)
 #define BOOST_CXX14_CONSTEXPR constexpr
 #else
@ -33,7 +36,10 @@

 #if (__cplusplus > 201700L || _MSVC_LANG > 201700L)
 #define BOOST_IF_CONSTEXPR if constexpr
-#if !__has_include(<execution>)
+
+// 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
 #else
@ -42,6 +48,10 @@
 #define BOOST_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
--- a/include/boost/math/tools/lexical_cast.hpp
+++ b/include/boost/math/tools/lexical_cast.hpp
@ -1,4 +1,4 @@
-//  (C) Copyright Matt Borland 2021
+//  (C) Copyright Matt Borland 2021 - 2022
 //  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)
@ -6,6 +6,9 @@
 #ifndef BOOST_MATH_TOOLS_LEXICAL_CAST
 #define BOOST_MATH_TOOLS_LEXICAL_CAST

+#include <cstdlib>
+#include <string>
+#include <type_traits>
 #include <boost/math/tools/is_standalone.hpp>

 #ifndef BOOST_MATH_STANDALONE
@ -17,11 +20,54 @@
 #endif

 namespace boost {
-    template <typename T1, typename T2>
-    inline T1 lexical_cast(const T2)
+
+    template <typename T, typename std::enable_if<std::is_same<T, float>::value, bool>::type = true>
+    inline T lexical_cast(const char* s)
    {
-        static_assert(sizeof(T1) == 0, "boost.lexical_cast can not be used in standalone mode. Please disable standalone mode and try again");
-        return T1(0);
+        return std::strtof(s, nullptr);
+    }
+
+    template <typename T, typename std::enable_if<std::is_same<T, double>::value, bool>::type = true>
+    inline T lexical_cast(const char* s)
+    {
+        return std::strtod(s, nullptr);
+    }
+
+    template <typename T, typename std::enable_if<std::is_same<T, long double>::value, bool>::type = true>
+    inline T lexical_cast(const char* s)
+    {
+        return std::strtold(s, nullptr);
+    }
+
+    template <typename T, typename std::enable_if<std::is_same<T, float>::value, bool>::type = true>
+    inline T lexical_cast(const std::string& s)
+    {
+        return std::strtof(s.c_str(), nullptr);
+    }
+
+    template <typename T, typename std::enable_if<std::is_same<T, double>::value, bool>::type = true>
+    inline T lexical_cast(const std::string& s)
+    {
+        return std::strtod(s.c_str(), nullptr);
+    }
+
+    template <typename T, typename std::enable_if<std::is_same<T, long double>::value, bool>::type = true>
+    inline T lexical_cast(const std::string& s)
+    {
+        return std::strtold(s.c_str(), nullptr);
+    }
+
+    template <typename T, typename T2, typename std::enable_if<(std::is_same<T, std::string>::value && std::is_arithmetic<T2>::value), bool>::type = true>
+    inline T lexical_cast(const T2 v)
+    {
+        return std::to_string(v);
+    }
+
+    template <typename T, typename T2, typename std::enable_if<(std::is_same<T, const char*>::value && std::is_arithmetic<T2>::value), bool>::type = true>
+    inline T lexical_cast(const T2 v)
+    {
+        const std::string temp = std::to_string(v);
+        return temp.c_str();
    }
 }
 #endif // BOOST_MATH_STANDALONE
--- a/include/boost/math/tools/polynomial.hpp
+++ b/include/boost/math/tools/polynomial.hpp
@ -27,6 +27,7 @@
 #include <algorithm>
 #include <initializer_list>
 #include <type_traits>
+#include <iterator>

 namespace boost{ namespace math{ namespace tools{

@ -293,7 +294,14 @@ public:

   template <class I>
   polynomial(I first, I last)
-   : m_data(first, last)
+      : m_data(first, last)
+   {
+       normalize();
+   }
+
+   template <class I>
+   polynomial(I first, unsigned length)
+      : m_data(first, std::next(first, length + 1))
   {
       normalize();
   }
@ -641,7 +649,7 @@ template <class T>
 inline polynomial<T> operator + (polynomial<T>&& a, const polynomial<T>& b)
 {
   a += b;
-   return a;
+   return std::move(a);
 }
 template <class T>
 inline polynomial<T> operator + (const polynomial<T>& a, polynomial<T>&& b)
--- a/include/boost/math/tools/polynomial_gcd.hpp
+++ b/include/boost/math/tools/polynomial_gcd.hpp
@ -19,38 +19,20 @@
 #ifndef BOOST_MATH_STANDALONE
 #include <boost/integer/common_factor_rt.hpp>

-// std::gcd was introduced in C++17
-#elif (__cplusplus > 201700L || _MSVC_LANG > 201700L)
-
-#define BOOST_MATH_CXX17_NUMERIC
+#else
 #include <numeric>
 #include <utility>
 #include <iterator>
 #include <type_traits>
 #include <boost/math/tools/assert.hpp>
+#include <boost/math/tools/config.hpp>

-namespace boost::integer {
-
-template <typename Iter, typename T = typename std::iterator_traits<Iter>::value_type>
-std::pair<T, Iter> gcd_range(Iter first, Iter last) noexcept(std::is_arithmetic_v<T>)
-{
-    using std::gcd;
-    BOOST_MATH_ASSERT(first != last);
-
-    T d = *first;
-    ++first;
-    while (d != T(1) && first != last)
-    {
-        d = gcd(d, *first);
-        ++first;
-    }
-    return std::make_pair(d, first);
-}
+namespace boost { namespace integer {

 namespace gcd_detail {

 template <typename EuclideanDomain>
-inline EuclideanDomain Euclid_gcd(EuclideanDomain a, EuclideanDomain b) noexcept(std::is_arithmetic_v<EuclideanDomain>)
+inline EuclideanDomain Euclid_gcd(EuclideanDomain a, EuclideanDomain b) noexcept(std::is_arithmetic<EuclideanDomain>::value)
 {
    using std::swap;
    while (b != EuclideanDomain(0))
@ -68,8 +50,28 @@ enum method_type
    method_mixed = 2
 };

-} // namespace gcd_detail
-} // namespace boost::integer
+} // gcd_detail
+
+template <typename Iter, typename T = typename std::iterator_traits<Iter>::value_type>
+std::pair<T, Iter> gcd_range(Iter first, Iter last) noexcept(std::is_arithmetic<T>::value)
+{
+    BOOST_MATH_ASSERT(first != last);
+
+    T d = *first;
+    ++first;
+    while (d != T(1) && first != last)
+    {
+        #ifdef BOOST_MATH_HAS_CXX17_NUMERIC
+        d = std::gcd(d, *first);
+        #else
+        d = gcd_detail::Euclid_gcd(d, *first);
+        #endif
+        ++first;
+    }
+    return std::make_pair(d, first);
+}
+
+}} // namespace boost::integer
 #endif

 namespace boost{
@ -108,10 +110,6 @@ namespace math{ namespace tools{
 template <class T>
 T content(polynomial<T> const &x)
 {
-    #if defined(BOOST_MATH_STANDALONE) && !defined(BOOST_MATH_CXX17_NUMERIC)
-    static_assert(sizeof(T) == 0, "polynomial gcd can only be used in standalone mode with C++17 or higher");
-    #endif
-
    return x ? boost::integer::gcd_range(x.data().begin(), x.data().end()).first : T(0);
 }

@ -146,18 +144,15 @@ namespace detail
    template <class T>
    T reduce_to_primitive(polynomial<T> &u, polynomial<T> &v)
    {
-        #ifndef BOOST_MATH_STANDALONE
-        using boost::integer::gcd;
-        #elif defined(BOOST_MATH_CXX17_NUMERIC)
-        using std::gcd;
-        #else
-        static_assert(sizeof(T) == 0, "polynomial gcd can only be used in standalone mode with C++17 or higher");
-        #endif
-
        T const u_cont = content(u), v_cont = content(v);
        u /= u_cont;
        v /= v_cont;
-        return gcd(u_cont, v_cont);
+
+        #ifdef BOOST_MATH_HAS_CXX17_NUMERIC
+        return std::gcd(u_cont, v_cont);
+        #else
+        return boost::integer::gcd_detail::Euclid_gcd(u_cont, v_cont);
+        #endif
    }
 }

@ -250,11 +245,7 @@ template <typename T>
 typename std::enable_if<!std::numeric_limits<T>::is_integer && (std::numeric_limits<T>::min_exponent != std::numeric_limits<T>::max_exponent) && !std::numeric_limits<T>::is_exact, polynomial<T> >::type
 gcd(polynomial<T> const &u, polynomial<T> const &v)
 {
-   #if defined(BOOST_MATH_STANDALONE) && !defined(BOOST_MATH_CXX17_NUMERIC)
-   static_assert(sizeof(T) == 0, "polynomial gcd can only be used in standalone mode with C++17 or higher");
-   #endif
-   
-   return boost::integer::gcd_detail::Euclid_gcd(u, v);
+    return boost::integer::gcd_detail::Euclid_gcd(u, v);
 }

 }
--- a/include/boost/math/tools/recurrence.hpp
+++ b/include/boost/math/tools/recurrence.hpp
@ -6,6 +6,9 @@
 #ifndef BOOST_MATH_TOOLS_RECURRENCE_HPP_
 #define BOOST_MATH_TOOLS_RECURRENCE_HPP_

+#include <type_traits>
+#include <tuple>
+#include <utility>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/tools/precision.hpp>
 #include <boost/math/tools/tuple.hpp>
@ -30,14 +33,14 @@ namespace boost {
            template <class Recurrence>
            struct function_ratio_from_backwards_recurrence_fraction
            {
-               typedef typename boost::remove_reference<decltype(boost::math::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;
+               typedef typename std::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;
               typedef std::pair<value_type, value_type> result_type;
               function_ratio_from_backwards_recurrence_fraction(const Recurrence& r) : r(r), k(0) {}

               result_type operator()()
               {
                  value_type a, b, c;
-                  boost::math::tie(a, b, c) = r(k);
+                  std::tie(a, b, c) = r(k);
                  ++k;
                  // an and bn defined as per Gauchi 1.16, not the same
                  // as the usual continued fraction a' and b's.
@ -57,11 +60,11 @@ namespace boost {
            struct recurrence_reverser
            {
               recurrence_reverser(const R& r) : r(r) {}
-               boost::math::tuple<T, T, T> operator()(int i)
+               std::tuple<T, T, T> operator()(int i)
               {
                  using std::swap;
-                  boost::math::tuple<T, T, T> t = r(-i);
-                  swap(boost::math::get<0>(t), boost::math::get<2>(t));
+                  std::tuple<T, T, T> t = r(-i);
+                  swap(std::get<0>(t), std::get<2>(t));
                  return t;
               }
               R r;
@ -139,8 +142,9 @@ namespace boost {
         inline T apply_recurrence_relation_forward(const NextCoefs& get_coefs, unsigned number_of_steps, T first, T second, long long* log_scaling = 0, T* previous = 0)
         {
            BOOST_MATH_STD_USING
-            using boost::math::tuple;
-            using boost::math::get;
+            using std::tuple;
+            using std::get;
+            using std::swap;

            T third;
            T a, b, c;
@ -194,8 +198,9 @@ namespace boost {
         inline T apply_recurrence_relation_backward(const NextCoefs& get_coefs, unsigned number_of_steps, T first, T second, long long* log_scaling = 0, T* previous = 0)
         {
            BOOST_MATH_STD_USING
-            using boost::math::tuple;
-            using boost::math::get;
+            using std::tuple;
+            using std::get;
+            using std::swap;

            T next;
            T a, b, c;
@ -235,7 +240,7 @@ namespace boost {
         template <class Recurrence>
         struct forward_recurrence_iterator
         {
-            typedef typename boost::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;
+            typedef typename std::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;

            forward_recurrence_iterator(const Recurrence& r, value_type f_n_minus_1, value_type f_n)
               : f_n_minus_1(f_n_minus_1), f_n(f_n), coef(r), k(0) {}
@ -252,7 +257,7 @@ namespace boost {
            {
               using std::swap;
               value_type a, b, c;
-               boost::math::tie(a, b, c) = coef(k);
+               std::tie(a, b, c) = coef(k);
               value_type f_n_plus_1 = a * f_n_minus_1 / -c + b * f_n / -c;
               swap(f_n_minus_1, f_n);
               swap(f_n, f_n_plus_1);
@ -277,7 +282,7 @@ namespace boost {
         template <class Recurrence>
         struct backward_recurrence_iterator
         {
-            typedef typename boost::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;
+            typedef typename std::remove_reference<decltype(std::get<0>(std::declval<Recurrence&>()(0)))>::type value_type;

            backward_recurrence_iterator(const Recurrence& r, value_type f_n_plus_1, value_type f_n)
               : f_n_plus_1(f_n_plus_1), f_n(f_n), coef(r), k(0) {}
@ -294,7 +299,7 @@ namespace boost {
            {
               using std::swap;
               value_type a, b, c;
-               boost::math::tie(a, b, c) = coef(k);
+               std::tie(a, b, c) = coef(k);
               value_type f_n_minus_1 = c * f_n_plus_1 / -a + b * f_n / -a;
               swap(f_n_plus_1, f_n);
               swap(f_n, f_n_minus_1);
--- a/include/boost/math/tr1.hpp
+++ b/include/boost/math/tr1.hpp
@ -106,8 +106,10 @@ namespace boost{ namespace math{ namespace tr1{ extern "C"{
 #  endif
 #  include <boost/config/auto_link.hpp>
 #endif
-#else
-#error Auto linking not supported in standalone mode.
+#else // Standalone mode
+#  ifdef _MSC_VER
+#    __pragma("Auto linking of TR1 is not supported in standalone mode")
+#  endif
 #endif // BOOST_MATH_STANDALONE

 #if !(defined(__INTEL_COMPILER) && defined(__APPLE__)) && !(defined(__FLT_EVAL_METHOD__) && !defined(__cplusplus))
--- a/include_private/boost/math/tools/test.hpp
+++ b/include_private/boost/math/tools/test.hpp
@ -102,7 +102,7 @@ void print_row(const Seq& row, std::ostream& os = std::cout)
 }

 //
-// Function test accepts an matrix of input values (probably a 2D boost::array)
+// Function test accepts an matrix of input values (probably a 2D std::array)
 // and calls two functors for each row in the array - one calculates a value
 // to test, and one extracts the expected value from the array (or possibly
 // calculates it at high precision).  The two functors are usually simple lambda
--- a/include_private/boost/math/tools/test_data.hpp
+++ b/include_private/boost/math/tools/test_data.hpp
@ -927,7 +927,7 @@ std::ostream& write_code(std::ostream& os,
      return os;

   os << "#ifndef SC_\n#  define SC_(x) static_cast<T>(BOOST_JOIN(x, L))\n#endif\n"
-   "   static const boost::array<boost::array<T, "
+   "   static const std::array<std::array<T, "
   << a->size() << ">, " << data.size() << "> " << name << " = {{\n";

   while(a != b)
--- a/reporting/performance/test_cn.cpp
+++ b/reporting/performance/test_cn.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-    static const boost::array<boost::array<T, 5>, 36> data1 = {{
+    static const std::array<std::array<T, 5>, 36> data1 = {{
        {{ SC_(0.0), SC_(0.0), SC_(0.0), SC_(1.0), SC_(1.0) }},
        {{ ldexp(T(1), -25), ldexp(T(1), -25), SC_(2.98023223876953080883700663838486782870427050521881839342311e-8), SC_(0.99999999999999955591079014993741669975171697261290223678373), SC_(0.99999999999999999999999999999960556954738949421406900774443) }},
        {{ -ldexp(T(1), -25), ldexp(T(1), -25), SC_(-2.98023223876953080883700663838486782870427050521881839342311e-8), SC_(0.99999999999999955591079014993741669975171697261290223678373), SC_(0.99999999999999999999999999999960556954738949421406900774443) }},
--- a/reporting/performance/test_digamma.cpp
+++ b/reporting/performance/test_digamma.cpp
@ -23,7 +23,7 @@ int main()
 #  include "digamma_root_data.ipp"
 #  include "digamma_small_data.ipp"
 #  include "digamma_neg_data.ipp"
-    static const boost::array<boost::array<T, 2>, 5> digamma_bugs = {{
+    static const std::array<std::array<T, 2>, 5> digamma_bugs = {{
       // Test cases from Rocco Romeo:
        {{ static_cast<T>(std::ldexp(1.0, -100)), SC_(-1.26765060022822940149670320537657721566490153286060651209008e30) }},
        {{ static_cast<T>(-std::ldexp(1.0, -100)), SC_(1.26765060022822940149670320537542278433509846713939348790992e30) }},
@ -31,10 +31,10 @@ int main()
        {{ static_cast<T>(-1) + static_cast<T>(std::ldexp(1.0, -20)), SC_(-1.04857557721314249602848739817764518743062133735858753112190e6) }},
        {{ static_cast<T>(-1) - static_cast<T>(std::ldexp(1.0, -20)), SC_(1.04857642278181269259522681939281063878220298942888100442172e6) }},
    }};
-   static const boost::array<boost::array<T, 2>, 40> digamma_integers = { {
+   static const std::array<std::array<T, 2>, 40> digamma_integers = { {
      { 1, SC_(-0.57721566490153286060651209008240243) }, { 2, SC_(0.42278433509846713939348790991759757) }, { 3, SC_(0.92278433509846713939348790991759757) }, { 4, SC_(1.2561176684318004727268212432509309) }, { 5, SC_(1.5061176684318004727268212432509309) }, { 6, SC_(1.7061176684318004727268212432509309) }, { 7, SC_(1.8727843350984671393934879099175976) }, { 8, SC_(2.0156414779556099965363450527747404) }, { 9, SC_(2.1406414779556099965363450527747404) }, { SC_(10.0), SC_(2.2517525890667211076474561638858515) }, { SC_(11.0), SC_(2.3517525890667211076474561638858515) }, { SC_(12.0), SC_(2.4426616799758120167383652547949424) }, { SC_(13.0), SC_(2.5259950133091453500716985881282758) }, { SC_(14.0), SC_(2.6029180902322222731486216650513527) }, { SC_(15.0), SC_(2.6743466616607937017200502364799241) }, { SC_(16.0), SC_(2.7410133283274603683867169031465908) }, { SC_(17.0), SC_(2.8035133283274603683867169031465908) }, { SC_(18.0), SC_(2.8623368577392250742690698443230614) }, { SC_(19.0), SC_(2.9178924132947806298246253998786169) }, { SC_(20.0), SC_(2.9705239922421490508772569788259854) }, { SC_(21.0), SC_(3.0205239922421490508772569788259854) }, { SC_(22.0), SC_(3.0681430398611966699248760264450330) }, { SC_(23.0), SC_(3.1135975853157421244703305718995784) }, { SC_(24.0), SC_(3.1570758461853073418616349197256654) }, { SC_(25.0), SC_(3.1987425128519740085283015863923321) }, { SC_(26.0), SC_(3.2387425128519740085283015863923321) }, { SC_(27.0), SC_(3.2772040513135124700667631248538705) }, { SC_(28.0), SC_(3.3142410883505495071038001618909076) }, { SC_(29.0), SC_(3.3499553740648352213895144476051933) }, { SC_(30.0), SC_(3.3844381326855248765619282407086415) }, { SC_(31.0), SC_(3.4177714660188582098952615740419749) }, { SC_(32.0), SC_(3.4500295305349872421533260901710071) }, { SC_(33.0), SC_(3.4812795305349872421533260901710071) }, { SC_(34.0), SC_(3.5115825608380175451836291204740374) }, { SC_(35.0), SC_(3.5409943255438998981248055910622727) }, { SC_(36.0), SC_(3.5695657541153284695533770196337013) }, { SC_(37.0), SC_(3.5973435318931062473311547974114791) }, { SC_(38.0), SC_(3.6243705589201332743581818244385061) }, { SC_(39.0), SC_(3.6506863483938174848844976139121903) }, { SC_(40.0), SC_(3.6763273740348431259101386395532160) }
   } };
-   static const boost::array<boost::array<T, 2>, 41> digamma_half_integers = { {
+   static const std::array<std::array<T, 2>, 41> digamma_half_integers = { {
      { SC_(0.5), SC_(-1.9635100260214234794409763329987556) }, { SC_(1.5), SC_(0.036489973978576520559023667001244433) }, { SC_(2.5), SC_(0.70315664064524318722569033366791110) }, { SC_(3.5), SC_(1.1031566406452431872256903336679111) }, { SC_(4.5), SC_(1.3888709263595289015114046193821968) }, { SC_(5.5), SC_(1.6110931485817511237336268416044190) }, { SC_(6.5), SC_(1.7929113303999329419154450234226009) }, { SC_(7.5), SC_(1.9467574842460867880692911772687547) }, { SC_(8.5), SC_(2.0800908175794201214026245106020880) }, { SC_(9.5), SC_(2.1977378764029495331673303929550292) }, { SC_(10.5), SC_(2.3030010342976863752725935508497661) }, { SC_(11.5), SC_(2.3982391295357816133678316460878613) }, { SC_(12.5), SC_(2.4851956512749120481504403417400352) }, { SC_(13.5), SC_(2.5651956512749120481504403417400352) }, { SC_(14.5), SC_(2.6392697253489861222245144158141093) }, { SC_(15.5), SC_(2.7082352425903654325693420020210058) }, { SC_(16.5), SC_(2.7727513716226234970854710342790703) }, { SC_(17.5), SC_(2.8333574322286841031460770948851310) }, { SC_(18.5), SC_(2.8905002893715412460032199520279881) }, { SC_(19.5), SC_(2.9445543434255953000572740060820421) }, { SC_(20.5), SC_(2.9958363947076465821085560573640934) }, { SC_(21.5), SC_(3.0446168825125246308890438622421422) }, { SC_(22.5), SC_(3.0911285104195013750750903738700492) }, { SC_(23.5), SC_(3.1355729548639458195195348183144936) }, { SC_(24.5), SC_(3.1781261463533075216471943927825787) }, { SC_(25.5), SC_(3.2189424728839197665451535764560481) }, { SC_(26.5), SC_(3.2581581591584295704667222039070285) }, { SC_(27.5), SC_(3.2958940082150333440516278642843870) }, { SC_(28.5), SC_(3.3322576445786697076879915006480234) }, { SC_(29.5), SC_(3.3673453638769153217230792199462690) }, { SC_(30.5), SC_(3.4012436689616610844349436267259300) }, { SC_(31.5), SC_(3.4340305542075627237792059218078972) }, { SC_(32.5), SC_(3.4657765859535944698109519535539290) }, { SC_(33.5), SC_(3.4965458167228252390417211843231597) }, { SC_(34.5), SC_(3.5263965629914819554596316320843538) }, { SC_(35.5), SC_(3.5553820702378587670538345306350784) }, { SC_(36.5), SC_(3.5835510843223658093073556573956418) }, { SC_(37.5), SC_(3.6109483445963384120470816847929021) }, { SC_(38.5), SC_(3.6376150112630050787137483514595687) }, { SC_(39.5), SC_(3.6635890372370310527397223774335947) }, { SC_(40.5), SC_(3.6889054929332335843852919976867593) }
   } };

--- a/reporting/performance/test_dn.cpp
+++ b/reporting/performance/test_dn.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-    static const boost::array<boost::array<T, 5>, 36> data1 = {{
+    static const std::array<std::array<T, 5>, 36> data1 = {{
        {{ SC_(0.0), SC_(0.0), SC_(0.0), SC_(1.0), SC_(1.0) }},
        {{ ldexp(T(1), -25), ldexp(T(1), -25), SC_(2.98023223876953080883700663838486782870427050521881839342311e-8), SC_(0.99999999999999955591079014993741669975171697261290223678373), SC_(0.99999999999999999999999999999960556954738949421406900774443) }},
        {{ -ldexp(T(1), -25), ldexp(T(1), -25), SC_(-2.98023223876953080883700663838486782870427050521881839342311e-8), SC_(0.99999999999999955591079014993741669975171697261290223678373), SC_(0.99999999999999999999999999999960556954738949421406900774443) }},
--- a/reporting/performance/test_ellint_1.cpp
+++ b/reporting/performance/test_ellint_1.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 19> data1 = { {
+static const std::array<std::array<T, 3>, 19> data1 = { {
   { { SC_(0.0), SC_(0.0), SC_(0.0) } },
   { { SC_(-10.0), SC_(0.0), SC_(-10.0) } },
   { { SC_(-1.0), SC_(-1.0), SC_(-1.2261911708835170708130609674719067527242483502207) } },
--- a/reporting/performance/test_ellint_1c.cpp
+++ b/reporting/performance/test_ellint_1c.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 2>, 9> data2 = { {
+static const std::array<std::array<T, 2>, 9> data2 = { {
   { { SC_(0.0), SC_(1.5707963267948966192313216916397514420985846996876) } },
   { { SC_(0.125), SC_(1.5769867712158131421244030532288080803822271060839) } },
   { { SC_(0.25), SC_(1.5962422221317835101489690714979498795055744578951) } },
--- a/reporting/performance/test_ellint_2.cpp
+++ b/reporting/performance/test_ellint_2.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 10> data1 = { {
+static const std::array<std::array<T, 3>, 10> data1 = { {
   { { SC_(0.0), SC_(0.0), SC_(0.0) } },
   { { SC_(-10.0), SC_(0.0), SC_(-10.0) } },
   { { SC_(-1.0), SC_(-1.0), SC_(-0.84147098480789650665250232163029899962256306079837) } },
--- a/reporting/performance/test_ellint_2c.cpp
+++ b/reporting/performance/test_ellint_2c.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 2>, 10> data2 = { {
+static const std::array<std::array<T, 2>, 10> data2 = { {
   { { SC_(-1.0), SC_(1.0) } },
   { { SC_(0.0), SC_(1.5707963267948966192313216916397514420985846996876) } },
   { { T(100) / 1024, SC_(1.5670445330545086723323795143598956428788609133377) } },
--- a/reporting/performance/test_ellint_3.cpp
+++ b/reporting/performance/test_ellint_3.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 4>, 65> data1 = { {
+static const std::array<std::array<T, 4>, 65> data1 = { {
   { { SC_(1.0), SC_(-1.0), SC_(0.0), SC_(-1.557407724654902230506974807458360173087) } },
   { { SC_(0.0), SC_(-4.0), SC_(0.4), SC_(-4.153623371196831087495427530365430979011) } },
   { { SC_(0.0), SC_(8.0), SC_(-0.6), SC_(8.935930619078575123490612395578518914416) } },
--- a/reporting/performance/test_in.cpp
+++ b/reporting/performance/test_in.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 10> i0_data = { {
+static const std::array<std::array<T, 3>, 10> i0_data = { {
   { { SC_(0.0), SC_(0.0), SC_(1.0) } },
   { { SC_(0.0), SC_(1.0), SC_(1.26606587775200833559824462521471753760767031135496220680814) } },
   { { SC_(0.0), SC_(-2.0), SC_(2.27958530233606726743720444081153335328584110278545905407084) } },
@ -29,7 +29,7 @@ static const boost::array<boost::array<T, 3>, 10> i0_data = { {
   { { SC_(0.0), SC_(100.0), SC_(1.07375170713107382351972085760349466128840319332527279540154e42) } },
   { { SC_(0.0), SC_(200.0), SC_(2.03968717340972461954167312677945962233267573614834337894328e85) } },
   } };
-static const boost::array<boost::array<T, 3>, 10> i1_data = { {
+static const std::array<std::array<T, 3>, 10> i1_data = { {
   { { SC_(1.0), SC_(0.0), SC_(0.0) } },
   { { SC_(1.0), SC_(1.0), SC_(0.565159103992485027207696027609863307328899621621092009480294) } },
   { { SC_(1.0), SC_(-2.0), SC_(-1.59063685463732906338225442499966624795447815949553664713229) } },
@ -41,7 +41,7 @@ static const boost::array<boost::array<T, 3>, 10> i1_data = { {
   { { SC_(1.0), SC_(100.0), SC_(1.06836939033816248120614576322429526544612284405623226965918e42) } },
   { { SC_(1.0), SC_(200.0), SC_(2.03458154933206270342742797713906950389661161681122964159220e85) } },
   } };
-static const boost::array<boost::array<T, 3>, 11> in_data = { {
+static const std::array<std::array<T, 3>, 11> in_data = { {
   { { SC_(-2.0), SC_(0.0), SC_(0.0) } },
   { { SC_(2.0), T(SC_(1.0)) / (1024 * 1024), SC_(1.13686837721624646204093977095674566928522671779753217215467e-13) } },
   { { SC_(5.0), SC_(10.0), SC_(777.188286403259959907293484802339632852674154572666041953297) } },
--- a/reporting/performance/test_iv.cpp
+++ b/reporting/performance/test_iv.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 10> iv_data = { {
+static const std::array<std::array<T, 3>, 10> iv_data = { {
   { { SC_(2.25), T(1) / (1024 * 1024), SC_(2.34379212133481347189068464680335815256364262507955635911656e-15) } },
   { { SC_(5.5), SC_(3.125), SC_(0.0583514045989371500460946536220735787163510569634133670181210) } },
   { { T(-5) + T(1) / 1024, SC_(2.125), SC_(0.0267920938009571023702933210070984416052633027166975342895062) } },
@ -29,7 +29,7 @@ static const boost::array<boost::array<T, 3>, 10> iv_data = { {
   { { T(144794) / 1024, SC_(200.0), SC_(2.23699739472246928794922868978337381373643889659337595319774e64) } },
   { { T(-144794) / 1024, SC_(100.0), SC_(2066.27694672763190927440969155740243346136463461655104698748) } },
   } };
-static const boost::array<boost::array<T, 3>, 5> iv_large_data = { {
+static const std::array<std::array<T, 3>, 5> iv_large_data = { {
      // Bug report https://svn.boost.org/trac/boost/ticket/5560:
   { { SC_(-1.0), static_cast<T>(ldexp(0.5, -512)), SC_(1.86458518280005168582274132886573345934411788365010172356788e-155) } },
   { { SC_(1.0), static_cast<T>(ldexp(0.5, -512)), SC_(1.86458518280005168582274132886573345934411788365010172356788e-155) } },
--- a/reporting/performance/test_jn.cpp
+++ b/reporting/performance/test_jn.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<typename table_type<T>::type, 3>, 8> j0_data = { {
+static const std::array<std::array<typename table_type<T>::type, 3>, 8> j0_data = { {
   { { SC_(0.0), SC_(0.0), SC_(1.0) } },
   { { SC_(0.0), SC_(1.0), SC_(0.7651976865579665514497175261026632209093) } },
   { { SC_(0.0), SC_(-2.0), SC_(0.2238907791412356680518274546499486258252) } },
@ -27,7 +27,7 @@ static const boost::array<boost::array<typename table_type<T>::type, 3>, 8> j0_d
   { { SC_(0.0), SC_(1e-10), SC_(0.999999999999999999997500000000000000000) } },
   { { SC_(0.0), SC_(-1e+01), SC_(-0.2459357644513483351977608624853287538296) } },
   } };
-static const boost::array<boost::array<T, 3>, 6> j0_tricky = { {
+static const std::array<std::array<T, 3>, 6> j0_tricky = { {
      // Big numbers make the accuracy of std::sin the limiting factor:
   { { SC_(0.0), SC_(1e+03), SC_(0.02478668615242017456133073111569370878617) } },
   { { SC_(0.0), SC_(1e+05), SC_(-0.001719201116235972192570601477073201747532) } },
@ -38,7 +38,7 @@ static const boost::array<boost::array<T, 3>, 6> j0_tricky = { {
   { { SC_(0.0), T(12364320.0) / (1024 * 1024), SC_(-3.53017140778223781420794006033810387155048392363051866610931e-9) } }
   } };

-static const boost::array<boost::array<typename table_type<T>::type, 3>, 8> j1_data = { {
+static const std::array<std::array<typename table_type<T>::type, 3>, 8> j1_data = { {
   { { SC_(1.0), SC_(0.0), SC_(0.0) } },
   { { SC_(1.0), SC_(1.0), SC_(0.4400505857449335159596822037189149131274) } },
   { { SC_(1.0), SC_(-2.0), SC_(-0.5767248077568733872024482422691370869203) } },
@ -48,7 +48,7 @@ static const boost::array<boost::array<typename table_type<T>::type, 3>, 8> j1_d
   { { SC_(1.0), SC_(1e-10), SC_(4.999999999999999999993750000000000000000e-11) } },
   { { SC_(1.0), SC_(-1e+01), SC_(-4.347274616886143666974876802585928830627e-02) } },
   } };
-static const boost::array<boost::array<T, 3>, 5> j1_tricky = { {
+static const std::array<std::array<T, 3>, 5> j1_tricky = { {
      // Big numbers make the accuracy of std::sin the limiting factor:
   { { SC_(1.0), SC_(1e+03), SC_(4.728311907089523917576071901216916285418e-03) } },
   { { SC_(1.0), SC_(1e+05), SC_(1.846757562882567716362123967114215743694e-03) } },
@ -58,7 +58,7 @@ static const boost::array<boost::array<T, 3>, 5> j1_tricky = { {
   { { SC_(1.0), T(10667654) / (1024 * 1024), SC_(1.24591331097191900488116495350277530373473085499043086981229e-7) } },
   } };

-static const boost::array<boost::array<typename table_type<T>::type, 3>, 17> jn_data = { {
+static const std::array<std::array<typename table_type<T>::type, 3>, 17> jn_data = { {
      // This first one is a modified test case from https://svn.boost.org/trac/boost/ticket/2733
   { { SC_(-1.0), SC_(1.25), SC_(-0.510623260319880467069474837274910375352924050139633057168856) } },
   { { SC_(2.0), SC_(0.0), SC_(0.0) } },
--- a/reporting/performance/test_jv.cpp
+++ b/reporting/performance/test_jv.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 21> jv_data = { {
+static const std::array<std::array<T, 3>, 21> jv_data = { {
      //SC_(-2.4), {{ SC_(0.0), std::numeric_limits<T>::infinity() }},
   { { T(22.5), T(0.0), SC_(0.0) } },
   { { T(2457.0) / 1024, T(1.0) / 1024, SC_(3.80739920118603335646474073457326714709615200130620574875292e-9) } },
--- a/reporting/performance/test_kn.cpp
+++ b/reporting/performance/test_kn.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 9> k0_data = { {
+static const std::array<std::array<T, 3>, 9> k0_data = { {
   { { SC_(0.0), SC_(1.0), SC_(0.421024438240708333335627379212609036136219748226660472298970) } },
   { { SC_(0.0), SC_(2.0), SC_(0.113893872749533435652719574932481832998326624388808882892530) } },
   { { SC_(0.0), SC_(4.0), SC_(0.0111596760858530242697451959798334892250090238884743405382553) } },
@ -28,7 +28,7 @@ static const boost::array<boost::array<T, 3>, 9> k0_data = { {
   { { SC_(0.0), SC_(50.0), SC_(3.41016774978949551392067551235295223184502537762334808993276e-23) } },
   { { SC_(0.0), SC_(100.0), SC_(4.65662822917590201893900528948388635580753948544211387402671e-45) } },
   } };
-static const boost::array<boost::array<T, 3>, 9> k1_data = { {
+static const std::array<std::array<T, 3>, 9> k1_data = { {
   { { SC_(1.0), SC_(1.0), SC_(0.601907230197234574737540001535617339261586889968106456017768) } },
   { { SC_(1.0), SC_(2.0), SC_(0.139865881816522427284598807035411023887234584841515530384442) } },
   { { SC_(1.0), SC_(4.0), SC_(0.0124834988872684314703841799808060684838415849886258457917076) } },
@ -39,7 +39,7 @@ static const boost::array<boost::array<T, 3>, 9> k1_data = { {
   { { SC_(1.0), SC_(50.0), SC_(3.44410222671755561259185303591267155099677251348256880221927e-23) } },
   { { SC_(1.0), SC_(100.0), SC_(4.67985373563690928656254424202433530797494354694335352937465e-45) } },
   } };
-static const boost::array<boost::array<T, 3>, 9> kn_data = { {
+static const std::array<std::array<T, 3>, 9> kn_data = { {
   { { SC_(2.0), T(std::ldexp(1.0, -30)), SC_(2.30584300921369395150000000000000000234841952009593636868109e18) } },
   { { SC_(5.0), SC_(10.0), SC_(0.0000575418499853122792763740236992723196597629124356739596921536) } },
   { { SC_(-5.0), SC_(100.0), SC_(5.27325611329294989461777188449044716451716555009882448801072e-45) } },
--- a/reporting/performance/test_kv.cpp
+++ b/reporting/performance/test_kv.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 11> kv_data = { {
+static const std::array<std::array<T, 3>, 11> kv_data = { {
   { { SC_(0.5), SC_(0.875), SC_(0.558532231646608646115729767013630967055657943463362504577189) } },
   { { SC_(0.5), SC_(1.125), SC_(0.383621010650189547146769320487006220295290256657827220786527) } },
   { { SC_(2.25), T(std::ldexp(1.0, -30)), SC_(5.62397392719283271332307799146649700147907612095185712015604e20) } },
@ -30,7 +30,7 @@ static const boost::array<boost::array<T, 3>, 11> kv_data = { {
   { { T(144793) / 1024, SC_(200.0), SC_(9.11950412043225432171915100042647230802198254567007382956336e-68) } },
   { { T(-144793) / 1024, SC_(50.0), SC_(1.30185229717525025165362673848737761549946548375142378172956e42) } },
   } };
-static const boost::array<boost::array<T, 3>, 5> kv_large_data = { {
+static const std::array<std::array<T, 3>, 5> kv_large_data = { {
      // Bug report https://svn.boost.org/trac/boost/ticket/5560:
   { { SC_(-1.0), static_cast<T>(ldexp(0.5, -512)), SC_(2.68156158598851941991480499964116922549587316411847867554471e154) } },
   { { SC_(1.0), static_cast<T>(ldexp(0.5, -512)), SC_(2.68156158598851941991480499964116922549587316411847867554471e154) } },
--- a/reporting/performance/test_polygamma.cpp
+++ b/reporting/performance/test_polygamma.cpp
--- a/reporting/performance/test_sn.cpp
+++ b/reporting/performance/test_sn.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-    static const boost::array<boost::array<T, 5>, 36> data1 = {{
+    static const std::array<std::array<T, 5>, 36> data1 = {{
        {{ SC_(0.0), SC_(0.0), SC_(0.0), SC_(1.0), SC_(1.0) }},
        {{ ldexp(T(1), -25), ldexp(T(1), -25), SC_(2.98023223876953080883700663838486782870427050521881839342311e-8), SC_(0.99999999999999955591079014993741669975171697261290223678373), SC_(0.99999999999999999999999999999960556954738949421406900774443) }},
        {{ -ldexp(T(1), -25), ldexp(T(1), -25), SC_(-2.98023223876953080883700663838486782870427050521881839342311e-8), SC_(0.99999999999999955591079014993741669975171697261290223678373), SC_(0.99999999999999999999999999999960556954738949421406900774443) }},
--- a/reporting/performance/test_trigamma.cpp
+++ b/reporting/performance/test_trigamma.cpp
--- a/reporting/performance/test_yn.cpp
+++ b/reporting/performance/test_yn.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<typename table_type<T>::type, 3>, 9> y0_data = { {
+static const std::array<std::array<typename table_type<T>::type, 3>, 9> y0_data = { {
   { { SC_(0.0), SC_(1.0), SC_(0.0882569642156769579829267660235151628278175230906755467110438) } },
   { { SC_(0.0), SC_(2.0), SC_(0.510375672649745119596606592727157873268139227085846135571839) } },
   { { SC_(0.0), SC_(4.0), SC_(-0.0169407393250649919036351344471532182404925898980149027169321) } },
@ -28,7 +28,7 @@ static const boost::array<boost::array<typename table_type<T>::type, 3>, 9> y0_d
   { { SC_(0.0), SC_(1e+03), SC_(0.00471591797762281339977326146566525500985900489680197718528000) } },
   { { SC_(0.0), SC_(1e+05), SC_(0.00184676615886506410434074102431546125884886798090392516843524) } }
   } };
-static const boost::array<boost::array<typename table_type<T>::type, 3>, 9> y1_data = { {
+static const std::array<std::array<typename table_type<T>::type, 3>, 9> y1_data = { {
   { { SC_(1.0), SC_(1.0), SC_(-0.781212821300288716547150000047964820549906390716444607843833) } },
   { { SC_(1.0), SC_(2.0), SC_(-0.107032431540937546888370772277476636687480898235053860525795) } },
   { { SC_(1.0), SC_(4.0), SC_(0.397925710557100005253979972450791852271189181622908340876586) } },
@ -39,7 +39,7 @@ static const boost::array<boost::array<typename table_type<T>::type, 3>, 9> y1_d
   { { SC_(1.0), SC_(1e+03), SC_(-0.0247843312923517789148623560971412909386318548648705287583490) } },
   { { SC_(1.0), SC_(1e+05), SC_(0.00171921035008825630099494523539897102954509504993494957572726) } }
   } };
-static const boost::array<boost::array<typename table_type<T>::type, 3>, 10> yn_data = { {
+static const std::array<std::array<typename table_type<T>::type, 3>, 10> yn_data = { {
   { { SC_(2.0), SC_(1e-20), SC_(-1.27323954473516268615107010698011489627570899691226996904849e40) } },
   { { SC_(5.0), SC_(10.0), SC_(0.135403047689362303197029014762241709088405766746419538495983) } },
   { { SC_(-5.0), SC_(1e+06), SC_(0.000331052088322609048503535570014688967096938338061796192422114) } },
--- a/reporting/performance/test_yv.cpp
+++ b/reporting/performance/test_yv.cpp
@ -17,7 +17,7 @@

 typedef double T;
 #define SC_(x) static_cast<double>(x)
-static const boost::array<boost::array<T, 3>, 11> yv_data = { {
+static const std::array<std::array<T, 3>, 11> yv_data = { {
      //SC_(2.25), {{ SC_(1.0) / 1024, SC_(-1.01759203636941035147948317764932151601257765988969544340275e7) }},
   { { SC_(0.5), T(1) / (1024 * 1024), SC_(-817.033790261762580469303126467917092806755460418223776544122) } },
   { { SC_(5.5), SC_(3.125), SC_(-2.61489440328417468776474188539366752698192046890955453259866) } },
@ -31,7 +31,7 @@ static const boost::array<boost::array<T, 3>, 11> yv_data = { {
   { { SC_(8.5), boost::math::constants::pi<T>() * 4, SC_(0.257086543428224355151772807588810984369026142375675714560864) } },
   { { SC_(-8.5), boost::math::constants::pi<T>() * 4, SC_(0.0436807946352780974532519564114026730332781693877984686758680) } },
   } };
-static const boost::array<boost::array<T, 3>, 7> yv_large_data = { {
+static const std::array<std::array<T, 3>, 7> yv_large_data = { {
      // Bug report https://svn.boost.org/trac/boost/ticket/5560:
   { { SC_(0.5), static_cast<T>(std::ldexp(0.5, -683)), SC_(-7.14823099969225685526188875418476476336424046896822867989728e102) } },
   { { SC_(-0.5), static_cast<T>(std::ldexp(0.5, -683)), SC_(8.90597649117647254543282704099383321071493400182381039079219e-104) } },
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -910,6 +910,8 @@ test-suite misc :
   ../build//boost_math_c99
   ../build//boost_math_c99f
   ../../test/build//boost_unit_test_framework
+   : : :
+   [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ]
     ]

   [ run test_tr1.cpp
@ -918,7 +920,8 @@ test-suite misc :
      ../../test/build//boost_unit_test_framework
      : : :
      <define>TEST_LD=1
-      [ check-target-builds ../config//has_long_double_support "long double support" : : <build>no ]
+      [ check-target-builds ../config//has_long_double_support "long double support" : : <build>no ] 
+      [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] 
      :
      test_tr1_long_double
     ]
@ -930,6 +933,7 @@ test-suite misc :
      ../build//boost_math_c99f
      ../../test/build//boost_unit_test_framework
      : : : #requirements
+      [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ]
      :
      test_tr1_c
    ]
@ -940,7 +944,8 @@ test-suite misc :
      ../../test/build//boost_unit_test_framework
      : : :
      <define>TEST_LD=1
-      [ check-target-builds ../config//has_long_double_support "long double support" : : <build>no ]
+      [ check-target-builds ../config//has_long_double_support "long double support" : : <build>no ] 
+      [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] 
      :
      test_tr1_c_long_double
    ]
@ -1268,7 +1273,7 @@ test-suite quadrature :
     [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] :
   tanh_sinh_quadrature_test_9 ]

-   [ run tanh_sinh_mpfr.cpp ../tools//mpfr ../tools//gmp : : : [ check-target-builds ../config//has_mpfr : : <build>no ] [ requires cxx11_hdr_initializer_list cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_smart_ptr ] release <toolset>clang:<cxxflags>-Wno-literal-range [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ] 
+   [ run tanh_sinh_mpfr.cpp ../tools//mpfr ../tools//gmp : : : [ check-target-builds ../config//has_mpfr : : <build>no ] [ check-target-builds ../config//has_gmp : : <build>no ] [ requires cxx11_hdr_initializer_list cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_smart_ptr ] release <toolset>clang:<cxxflags>-Wno-literal-range [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ] 
   [ run sinh_sinh_quadrature_test.cpp ../../test/build//boost_unit_test_framework
     : : : release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] ]
   [ run exp_sinh_quadrature_test.cpp ../../test/build//boost_unit_test_framework
@ -1449,7 +1454,7 @@ test-suite autodiff :
   [ run test_autodiff_5.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
   [ run test_autodiff_6.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
   [ run test_autodiff_7.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
-   [ run test_autodiff_8.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
+   [ run test_autodiff_8.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ check-target-builds ../config//is_ci_standalone_run "Standalone CI run" : <build>no ] [ requires cxx11_inline_namespaces ] ]
   [ compile compile_test/diff_autodiff_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
   [ compile compile_test/diff_finite_difference_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
   [ compile compile_test/diff_lanczos_smoothing_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
--- a/test/acosh_data.ipp
+++ b/test/acosh_data.ipp
@ -6,7 +6,7 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)

 #define SC_(x) static_cast<typename table_type<T>::type>(BOOST_JOIN(x, L))
-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 261> acosh_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 2>, 261> acosh_data = {{
      {{ SC_(1.000001430511474609375), SC_(0.001691455665129294448190238354291760044433) }}, 
      {{ SC_(1.0000019073486328125), SC_(0.001953124689559275021527821917817027620963) }}, 
      {{ SC_(1.000007152557373046875), SC_(0.003782208044661295168504799813496158490314) }}, 
--- a/test/asinh_data.ipp
+++ b/test/asinh_data.ipp
@ -6,7 +6,7 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)

 #define SC_(x) static_cast<typename table_type<T>::type>(BOOST_JOIN(x, L))
-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 281> asinh_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 2>, 281> asinh_data = {{
      {{ SC_(-497.181640625), SC_(-6.902103625349694816896128061929344488774) }}, 
      {{ SC_(-495.216552734375), SC_(-6.898143347143858285101511567975488446084) }}, 
      {{ SC_(-488.0980224609375), SC_(-6.883664481302669222996695409880306523751) }}, 
--- a/test/assoc_legendre_p.ipp
+++ b/test/assoc_legendre_p.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 4>, 400> assoc_legendre_p = {{
+   static const std::array<std::array<typename table_type<T>::type, 4>, 400> assoc_legendre_p = {{
      {{ SC_(3.755727291107177734375), SC_(-3.0), SC_(0.264718532562255859375), SC_(0.018682285998021253444483874168352748715136623066073) }}, 
      {{ SC_(3.755727291107177734375), SC_(-3.0), SC_(0.67001712322235107421875), SC_(0.0085227010576716344744906184676725516467064196759033) }}, 
      {{ SC_(3.755727291107177734375), SC_(-3.0), SC_(0.91501367092132568359375), SC_(0.0013678553914178941694232605088191864494205442141689) }}, 
--- a/test/atanh_data.ipp
+++ b/test/atanh_data.ipp
@ -6,7 +6,7 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)

 #define SC_(x) static_cast<typename table_type<T>::type>(BOOST_JOIN(x, L))
-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 260> atanh_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 2>, 260> atanh_data = {{
      {{ SC_(-0.9999983310699462890625), SC_(-6.998237084679026894944012639589359039154) }}, 
      {{ SC_(-0.9999978542327880859375), SC_(-6.872579751329170618373487147465365112113) }}, 
      {{ SC_(-0.999992847442626953125), SC_(-6.270592097465752658938563627507298840894) }}, 
--- a/test/bessel_i_data.ipp
+++ b/test/bessel_i_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 225> bessel_i_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 225> bessel_i_data = {{
      {{ SC_(-0.8049192047119140625e2), SC_(0.24750102996826171875e2), SC_(0.4186983670927603951456761016615805321694e29) }}, 
      {{ SC_(-0.8049192047119140625e2), SC_(0.637722015380859375e2), SC_(0.2032477564839492547710163141114983376107e7) }}, 
      {{ SC_(-0.7460263824462890625e2), SC_(0.24750102996826171875e2), SC_(0.7209773983625557491285409746913864781653e24) }}, 
--- a/test/bessel_i_int_data.ipp
+++ b/test/bessel_i_int_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 495> bessel_i_int_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 495> bessel_i_int_data = {{
      {{ SC_(0.0), SC_(0.177219114266335964202880859375e-2), SC_(0.1000000785165515654790765567976560128368e1) }}, 
      {{ SC_(0.0), SC_(0.22177286446094512939453125e-2), SC_(0.1000001229580463247166647265657459686513e1) }}, 
      {{ SC_(0.0), SC_(0.7444499991834163665771484375e-2), SC_(0.1000013855193023439561602999309818071557e1) }}, 
--- a/test/bessel_i_prime_data.ipp
+++ b/test/bessel_i_prime_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 450
+   static const std::array<std::array<typename table_type<T>::type, 3>, 450
 #if LDBL_MAX_10_EXP < 370
      - 36
 #endif
--- a/test/bessel_i_prime_int_data.ipp
+++ b/test/bessel_i_prime_int_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 1980> bessel_i_prime_int_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 1980> bessel_i_prime_int_data = {{
      {{ SC_(0.0), SC_(0.177219114266335964202880859375e-2), SC_(0.00088609591919750015203076551463481289812081759457593) }}, 
      {{ SC_(0.0), SC_(0.22177286446094512939453125e-2), SC_(0.0011088650040236093434924259738776777082777117728366) }}, 
      {{ SC_(0.0), SC_(0.7444499991834163665771484375e-2), SC_(0.003722275782133396649790935284938128705516556817227) }}, 
--- a/test/bessel_j_data.ipp
+++ b/test/bessel_j_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 360> bessel_j_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 360> bessel_j_data = {{
      {{ SC_(0.4430477856658399105072021484375e-3), SC_(0.553809732082299888134002685546875e-4), SC_(0.9956156809860747445801192500664050062602e0) }}, 
      {{ SC_(0.4430477856658399105072021484375e-3), SC_(0.69304020144045352935791015625e-4), SC_(0.9957146107589140226790508756099801328105e0) }}, 
      {{ SC_(0.4430477856658399105072021484375e-3), SC_(0.23264062474481761455535888671875e-3), SC_(0.9962489699005580621378590557841736186861e0) }}, 
--- a/test/bessel_j_int_data.ipp
+++ b/test/bessel_j_int_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 224> bessel_j_int_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 224> bessel_j_int_data = {{
      {{ SC_(0.0), SC_(0.1730655412757187150418758392333984375e-5), SC_(0.999999999999251207960573702716351702855e0) }}, 
      {{ SC_(0.0), SC_(0.216575062950141727924346923828125e-5), SC_(0.9999999999988273810527038974545295287162e0) }}, 
      {{ SC_(0.0), SC_(0.72700195232755504548549652099609375e-5), SC_(0.9999999999867867040328417323221266089012e0) }}, 
--- a/test/bessel_j_large_data.ipp
+++ b/test/bessel_j_large_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 70> bessel_j_large_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 70> bessel_j_large_data = {{
      {{ SC_(0.725889492034912109375e1), SC_(0.725889492034912109375e1), SC_(0.2307850131230964328215158373258970201933e0) }}, 
      {{ SC_(0.725889492034912109375e1), SC_(0.90838165283203125e1), SC_(0.331270090805281544869225081474258975783e0) }}, 
      {{ SC_(0.725889492034912109375e1), SC_(0.30492671966552734375e2), SC_(0.1392044369140870127137144436194280008198e0) }}, 
--- a/test/bessel_j_prime_data.ipp
+++ b/test/bessel_j_prime_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 720
+   static const std::array<std::array<typename table_type<T>::type, 3>, 720
 #if LDBL_MAX_10_EXP < 370
      - 5
 #endif
--- a/test/bessel_j_prime_int_data.ipp
+++ b/test/bessel_j_prime_int_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 896> bessel_j_prime_int_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 896> bessel_j_prime_int_data = {{
      {{ SC_(0.0), SC_(0.1730655412757187150418758392333984375e-5), SC_(-8.6532770637826959996036352233123749969269387214742e-07) }}, 
      {{ SC_(0.0), SC_(0.216575062950141727924346923828125e-5), SC_(-1.082875314750073739565916601264494477250584335342e-06) }}, 
      {{ SC_(0.0), SC_(0.72700195232755504548549652099609375e-5), SC_(-3.6350097616137599975154414859780356083927094699044e-06) }}, 
--- a/test/bessel_j_prime_large_data.ipp
+++ b/test/bessel_j_prime_large_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 140> bessel_j_prime_large_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 140> bessel_j_prime_large_data = {{
      {{ SC_(0.725889492034912109375e1), SC_(0.725889492034912109375e1), SC_(0.10324136466803984563203229652469623629494905060386) }}, 
      {{ SC_(0.725889492034912109375e1), SC_(0.90838165283203125e1), SC_(-0.02593519786909798552765612804866897946479440240923) }}, 
      {{ SC_(0.725889492034912109375e1), SC_(0.30492671966552734375e2), SC_(-0.047080257597058131629810223790028536535803474378352) }}, 
--- a/test/bessel_k_data.ipp
+++ b/test/bessel_k_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 263> bessel_k_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 263> bessel_k_data = {{
      {{ SC_(-0.8049192047119140625e2), SC_(0.24750102996826171875e2), SC_(0.6579017807810652710369517871806355927214e29) }}, 
      {{ SC_(-0.8049192047119140625e2), SC_(0.637722015380859375e2), SC_(0.2395518238062557960566710371847643552469e-8) }}, 
      {{ SC_(-0.8049192047119140625e2), SC_(0.1252804412841796875e3), SC_(0.3069043255911758700865294859650240330974e-44) }}, 
--- a/test/bessel_k_int_data.ipp
+++ b/test/bessel_k_int_data.ipp
@ -2,7 +2,7 @@
 //  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)
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 481> bessel_k_int_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 481> bessel_k_int_data = {{
      {{ SC_(0.0), SC_(0.177219114266335964202880859375e-2), SC_(0.6451475930592273598846015135698055330078e1) }}, 
      {{ SC_(0.0), SC_(0.22177286446094512939453125e-2), SC_(0.6227212142001190939808570915268231760654e1) }}, 
      {{ SC_(0.0), SC_(0.7444499991834163665771484375e-2), SC_(0.5016294646816679195434588077252051358532e1) }}, 
--- a/test/bessel_k_prime_data.ipp
+++ b/test/bessel_k_prime_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 526> bessel_k_prime_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 526> bessel_k_prime_data = {{
      {{ SC_(-0.8049192047119140625e2), SC_(0.24750102996826171875e2), SC_(-223964241238127376907362933849.77811883621356945072) }}, 
      {{ SC_(-0.8049192047119140625e2), SC_(0.637722015380859375e2), SC_(-3.8648041779027959239388782349048349624084267353648e-09) }}, 
      {{ SC_(-0.8049192047119140625e2), SC_(0.1252804412841796875e3), SC_(-3.6565779603591655562583295314803218468260642362413e-45) }}, 
--- a/test/bessel_k_prime_int_data.ipp
+++ b/test/bessel_k_prime_int_data.ipp
@ -2,7 +2,7 @@
 //  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)
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 962> bessel_k_prime_int_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 962> bessel_k_prime_int_data = {{
      {{ SC_(0.0), SC_(0.177219114266335964202880859375e-2), SC_(-564.26705890503944938767579913547914444248945617307) }}, 
      {{ SC_(0.0), SC_(0.22177286446094512939453125e-2), SC_(-450.90433365191537768820321413950713211111795723233) }}, 
      {{ SC_(0.0), SC_(0.7444499991834163665771484375e-2), SC_(-134.30682303430738211464350075539051302297649874874) }}, 
--- a/test/bessel_y01_data.ipp
+++ b/test/bessel_y01_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 100> bessel_y01_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 100> bessel_y01_data = {{
      {{ SC_(0.0), SC_(0.23917420208454132080078125e0), SC_(-0.96144387845032600014206252125473909797e0) }}, 
      {{ SC_(0.0), SC_(0.1785583972930908203125e1), SC_(0.4741447443427281185149710186267060231689e0) }}, 
      {{ SC_(0.0), SC_(0.48770198822021484375e1), SC_(-0.2878028614684715596290259912770720755831e0) }}, 
--- a/test/bessel_y01_prime_data.ipp
+++ b/test/bessel_y01_prime_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 200> bessel_y01_prime_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 200> bessel_y01_prime_data = {{
      {{ SC_(0.0), SC_(0.23917420208454132080078125e0), SC_(2.8160255059578487028902306927374355839994931221929) }}, 
      {{ SC_(0.0), SC_(0.1785583972930908203125e1), SC_(0.23235748809524737566987412330781331582320965659276) }}, 
      {{ SC_(0.0), SC_(0.48770198822021484375e1), SC_(-0.1887793753606189589996790522700420589944901022832) }}, 
--- a/test/bessel_yn_data.ipp
+++ b/test/bessel_yn_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 300> bessel_yn_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 300> bessel_yn_data = {{
      {{ SC_(0.3e1), SC_(0.48770198822021484375e1), SC_(0.110763167474753768460862899966350902213e0) }}, 
      {{ SC_(0.3e1), SC_(0.6349340915679931640625e1), SC_(0.3354120577583840086404698897976135110485e0) }}, 
      {{ SC_(0.3e1), SC_(0.677385044097900390625e1), SC_(0.3025179709577162581120705977708622170952e0) }}, 
--- a/test/bessel_yn_prime_data.ipp
+++ b/test/bessel_yn_prime_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 600> bessel_yn_prime_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 600> bessel_yn_prime_data = {{
      {{ SC_(0.3e1), SC_(0.48770198822021484375e1), SC_(0.29708501519972432874442609586225264980095279453487) }}, 
      {{ SC_(0.3e1), SC_(0.6349340915679931640625e1), SC_(-0.024696224449710501462629183400498863527821680586339) }}, 
      {{ SC_(0.3e1), SC_(0.677385044097900390625e1), SC_(-0.12798507472726383423677638554544275695549764510857) }}, 
--- a/test/bessel_yv_data.ipp
+++ b/test/bessel_yv_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 432> bessel_yv_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 432> bessel_yv_data = {{
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.177219114266335964202880859375e-2), SC_(-0.4109981080896677237358777348659577384814e1) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.22177286446094512939453125e-2), SC_(-0.3967198166482792888587309535339999462266e1) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.7444499991834163665771484375e-2), SC_(-0.3196174808457488271204616814902805588745e1) }}, 
--- a/test/bessel_yv_prime_data.ipp
+++ b/test/bessel_yv_prime_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 864> bessel_yv_prime_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 864> bessel_yv_prime_data = {{
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.177219114266335964202880859375e-2), SC_(359.25306691468182462382237111287002162553866747579) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.22177286446094512939453125e-2), SC_(287.08013716324049922227602244564319388641879278396) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.7444499991834163665771484375e-2), SC_(85.531475792801076416765903757627138355150815768381) }}, 
--- a/test/beta_exp_data.ipp
+++ b/test/beta_exp_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 351> beta_exp_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 3>, 351> beta_exp_data = { {
      {{ SC_(0.1730655412757187150418758392333984375e-5), SC_(0.1730655412757187150418758392333984375e-5), SC_(1155631.551635027016649268884796909927277) }}, 
      {{ SC_(0.216575062950141727924346923828125e-5), SC_(0.1730655412757187150418758392333984375e-5), SC_(1039549.452063747329381617654200841254652) }}, 
      {{ SC_(0.216575062950141727924346923828125e-5), SC_(0.216575062950141727924346923828125e-5), SC_(923467.3524924676425690820378921903570447) }}, 
--- a/test/beta_med_data.ipp
+++ b/test/beta_med_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 1830> beta_med_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 3>, 1830> beta_med_data = { {
      {{ SC_(0.4883005917072296142578125), SC_(0.4883005917072296142578125), SC_(3.245912809500479157065104747353807392371) }}, 
      {{ SC_(3.5808107852935791015625), SC_(0.4883005917072296142578125), SC_(1.007653173802923954909901438393379243537) }}, 
      {{ SC_(3.5808107852935791015625), SC_(3.5808107852935791015625), SC_(0.01354763979296020361276499134253466025558) }}, 
--- a/test/beta_small_data.ipp
+++ b/test/beta_small_data.ipp
@ -5,7 +5,7 @@

 using std::ldexp;

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 23> beta_small_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 3>, 23> beta_small_data = { {
      {{ SC_(0.1730655412757187150418758392333984375e-5), SC_(0.1730655412757187150418758392333984375e-5), SC_(1155631.551635027016649268884796909927277) }},
      {{ SC_(0.216575062950141727924346923828125e-5), SC_(0.1730655412757187150418758392333984375e-5), SC_(1039549.452063747329381617654200841254652) }},
      {{ SC_(0.216575062950141727924346923828125e-5), SC_(0.216575062950141727924346923828125e-5), SC_(923467.3524924676425690820378921903570447) }},
--- a/test/binomial_data.ipp
+++ b/test/binomial_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 159> binomial_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 3>, 159> binomial_data = { {
      {{ SC_(0.15e2), SC_(0.15e2), SC_(0.1e1) }}, 
      {{ SC_(0.19e2), SC_(0.15e2), SC_(0.3876e4) }}, 
      {{ SC_(0.19e2), SC_(0.19e2), SC_(0.1e1) }}, 
--- a/test/binomial_large_data.ipp
+++ b/test/binomial_large_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 230> binomial_large_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 3>, 230> binomial_large_data = { {
      {{ SC_(0.174e3), SC_(0.4e1), SC_(0.36890001e8) }}, 
      {{ SC_(0.174e3), SC_(0.5e1), SC_(0.1254260034e10) }}, 
      {{ SC_(0.174e3), SC_(0.6e1), SC_(0.35328324291e11) }}, 
--- a/test/binomial_quantile.ipp
+++ b/test/binomial_quantile.ipp
@ -4,7 +4,7 @@
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 #define SC_(x) static_cast<typename table_type<T>::type>(BOOST_JOIN(x, L))
-   static const boost::array<boost::array<T, 5>, 4032> binomial_quantile_data = {{
+   static const std::array<std::array<T, 5>, 4032> binomial_quantile_data = {{
      {{ SC_(2.0), SC_(0.12698681652545928955078125), SC_(0.12698681652545928955078125), SC_(0.0), SC_(0.28467385230321224203411154382440248724380832183117) }}, 
      {{ SC_(2.0), SC_(0.12698681652545928955078125), SC_(0.135477006435394287109375), SC_(0.0), SC_(0.25727865882740919932840773421531232758964168093055) }}, 
      {{ SC_(2.0), SC_(0.12698681652545928955078125), SC_(0.22103404998779296875), SC_(0.0), SC_(0.035694410305790976496105074803969225386555435216338) }}, 
--- a/test/cbrt_data.ipp
+++ b/test/cbrt_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 85> cbrt_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 2>, 85> cbrt_data = { {
      {{ SC_(0.266297021326439287136622624529991298914e-12), SC_(0.1888421455001568264216782004847867296461e-37) }}, 
      {{ SC_(0.5920415525016708979677559909760020673275e-12), SC_(0.2075183790343685754527643464587844863336e-36) }}, 
      {{ SC_(0.155163989296047688526414276566356420517e-11), SC_(0.3735707037930203997047439019589434984292e-35) }}, 
--- a/test/centered_continued_fraction_test.cpp
+++ b/test/centered_continued_fraction_test.cpp
@ -13,6 +13,7 @@
 using boost::multiprecision::float128;
 #endif
 #include <boost/multiprecision/cpp_bin_float.hpp>
+#include <boost/core/demangle.hpp>

 using boost::math::tools::centered_continued_fraction;
 using boost::multiprecision::cpp_bin_float_100;
--- a/test/chebyshev_test.cpp
+++ b/test/chebyshev_test.cpp
@ -73,17 +73,17 @@ template<class Real>
 void test_clenshaw_recurrence()
 {
    using boost::math::chebyshev_clenshaw_recurrence;
-    boost::array<Real, 5> c0 = { {2, 0, 0, 0, 0} };
+    std::array<Real, 5> c0 = { {2, 0, 0, 0, 0} };
    // Check the size = 1 case:
-    boost::array<Real, 1> c01 = { {2} };
+    std::array<Real, 1> c01 = { {2} };
    // Check the size = 2 case:
-    boost::array<Real, 2> c02 = { {2, 0} };
-    boost::array<Real, 4> c1 = { {0, 1, 0, 0} };
-    boost::array<Real, 4> c2 = { {0, 0, 1, 0} };
-    boost::array<Real, 5> c3 = { {0, 0, 0, 1, 0} };
-    boost::array<Real, 5> c4 = { {0, 0, 0, 0, 1} };
-    boost::array<Real, 6> c5 = { {0, 0, 0, 0, 0, 1} };
-    boost::array<Real, 7> c6 = { {0, 0, 0, 0, 0, 0, 1} };
+    std::array<Real, 2> c02 = { {2, 0} };
+    std::array<Real, 4> c1 = { {0, 1, 0, 0} };
+    std::array<Real, 4> c2 = { {0, 0, 1, 0} };
+    std::array<Real, 5> c3 = { {0, 0, 0, 1, 0} };
+    std::array<Real, 5> c4 = { {0, 0, 0, 0, 1} };
+    std::array<Real, 6> c5 = { {0, 0, 0, 0, 0, 1} };
+    std::array<Real, 7> c6 = { {0, 0, 0, 0, 0, 0, 1} };

    Real x = -1;
    // It's not clear from this test which one is more accurate; higher precision cast testing is required, and is done elsewhere:
--- a/test/compile_test/cstdfloat_concept_check_1.cpp
+++ b/test/compile_test/cstdfloat_concept_check_1.cpp
@ -23,4 +23,6 @@ int main(int
 #endif
 }

+#else
+int main(void) { return 0; }
 #endif
--- a/test/compile_test/cstdfloat_concept_check_2.cpp
+++ b/test/compile_test/cstdfloat_concept_check_2.cpp
@ -23,4 +23,6 @@ int main(int
 #endif
 }

+#else
+int main(void) { return 0; }
 #endif
--- a/test/compile_test/cstdfloat_concept_check_3.cpp
+++ b/test/compile_test/cstdfloat_concept_check_3.cpp
@ -24,4 +24,6 @@ int main(int
 #endif
 }

+#else
+int main(void) { return 0; }
 #endif
--- a/test/compile_test/cstdfloat_concept_check_4.cpp
+++ b/test/compile_test/cstdfloat_concept_check_4.cpp
@ -24,4 +24,6 @@ int main(int
 #endif
 }

+#else
+int main(void) { return 0; }
 #endif
--- a/test/compile_test/interpolators_catmull_rom_concept_test.cpp
+++ b/test/compile_test/interpolators_catmull_rom_concept_test.cpp
@ -4,13 +4,13 @@
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //

-#ifndef BOOST_MATH_STANDALONE
-
+#include <boost/math/tools/config.hpp>
 #include <boost/math/concepts/std_real_concept.hpp>
 #include <boost/math/interpolators/catmull_rom.hpp>

 void compile_and_link_test()
 {
+    #ifndef BOOST_MATH_NO_REAL_CONCEPT_TESTS
    std::vector<boost::math::concepts::std_real_concept> p0{0.1, 0.2, 0.3};
    std::vector<boost::math::concepts::std_real_concept> p1{0.2, 0.3, 0.4};
    std::vector<boost::math::concepts::std_real_concept> p2{0.3, 0.4, 0.5};
@ -21,6 +21,5 @@ void compile_and_link_test()
    boost::math::catmull_rom<std::vector<boost::math::concepts::std_real_concept>> cat(std::move(v));
    cat(0.0);
    cat.prime(0.0);
+    #endif
 }
-
-#endif
--- a/test/digamma_data.ipp
+++ b/test/digamma_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 500> digamma_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 2>, 500> digamma_data = { {
      {{ SC_(2.818432331085205078125), SC_(0.8484115700906551606307984398000472347785) }}, 
      {{ SC_(4.6342258453369140625), SC_(1.421713669467331557347601964119226105014) }}, 
      {{ SC_(4.783483982086181640625), SC_(1.457016504476551729585831562031964212238) }}, 
--- a/test/digamma_neg_data.ipp
+++ b/test/digamma_neg_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 200> digamma_neg_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 2>, 200> digamma_neg_data = { {
      {{ SC_(-99.7181549072265625), SC_(2.03892909952497242038694056382195623059) }}, 
      {{ SC_(-99.5216522216796875), SC_(4.3913617771941913117971009646096341326) }}, 
      {{ SC_(-98.80979156494140625), SC_(-0.01795976054399933340057713377738267488686) }}, 
--- a/test/digamma_root_data.ipp
+++ b/test/digamma_root_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 200> digamma_root_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 2>, 200> digamma_root_data = { {
      {{ SC_(1.39999997615814208984375), SC_(-0.06138456903152256550686860248931989075643) }}, 
      {{ SC_(1.4005000591278076171875), SC_(-0.06087192929516339380130503872301167293378) }}, 
      {{ SC_(1.40100002288818359375), SC_(-0.06035965880979232302674791723368356347747) }}, 
--- a/test/digamma_small_data.ipp
+++ b/test/digamma_small_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 33> digamma_small_data = { {
+   static const std::array<std::array<typename table_type<T>::type, 2>, 33> digamma_small_data = { {
      {{ SC_(0.1690093176520690576580818742513656616211e-8), SC_(-591683355.0172646248558707395909205014789) }}, 
      {{ SC_(0.2114990849122477811761200428009033203125e-8), SC_(-472815285.0570071002693788265718597340393) }}, 
      {{ SC_(0.7099628440698779741069301962852478027344e-8), SC_(-140852442.1314070676912450420112690472767) }}, 
--- a/test/ellint_d2_data.ipp
+++ b/test/ellint_d2_data.ipp
@ -6,7 +6,7 @@
 #ifndef SC_
 #  define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
 #endif
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 900> ellint_d2_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 900> ellint_d2_data = {{
      {{ SC_(-1.6098388671875000000000000000000000000000e+01), SC_(1.6900929544760856515495106577873229980469e-09), SC_(-7.8732233320862771639280819567039935203140e+00) }}, 
      {{ SC_(-1.6098388671875000000000000000000000000000e+01), SC_(2.1149908491224778117612004280090332031250e-09), SC_(-7.8732233320862771686912327739413416253147e+00) }}, 
      {{ SC_(-1.6098388671875000000000000000000000000000e+01), SC_(7.0996275525203600409440696239471435546875e-09), SC_(-7.8732233320862773040094892394481766236413e+00) }}, 
--- a/test/ellint_d_data.ipp
+++ b/test/ellint_d_data.ipp
@ -6,7 +6,7 @@
 #ifndef SC_
 #  define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
 #endif
-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 125> ellint_d_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 2>, 125> ellint_d_data = {{
      {{ SC_(4.2663944255221095139880438282681452852288e-38), SC_(7.8539816339744830961566084581987572104929e-01) }}, 
      {{ SC_(5.3389875064733255949510523157465792097624e-38), SC_(7.8539816339744830961566084581987572104929e-01) }}, 
      {{ SC_(1.7921979577002392819066727539424713436648e-37), SC_(7.8539816339744830961566084581987572104929e-01) }}, 
--- a/test/ellint_e2_data.ipp
+++ b/test/ellint_e2_data.ipp
@ -7,7 +7,7 @@
 //
 // k, phi, E(k, phi)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 520> ellint_e2_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 520> ellint_e2_data = {{
      {{ SC_(0.177219114266335964202880859375e-2), SC_(-0.804919183254241943359375e0), SC_(0.17721905416489978459933452744691987573693030723399e-2) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(-0.74602639675140380859375e0), SC_(0.17721906263793616232304803862551613935165980878975e-2) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(-0.72904598712921142578125e0), SC_(0.17721906496143189532808590572077500756745196250994e-2) }}, 
--- a/test/ellint_e_data.ipp
+++ b/test/ellint_e_data.ipp
@ -7,7 +7,7 @@
 //
 // k, E(k)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 100> ellint_e_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 2>, 100> ellint_e_data = {{
      {{ SC_(-0.990433037281036376953125e0), SC_(0.10274527688571687030049782227296053357094496206279e1) }}, 
      {{ SC_(-0.936334311962127685546875e0), SC_(0.11232874555917022066938321555637623562213676975972e1) }}, 
      {{ SC_(-0.931107819080352783203125e0), SC_(0.1130760221755419903369153157619439589360779303926e1) }}, 
--- a/test/ellint_f_data.ipp
+++ b/test/ellint_f_data.ipp
@ -8,7 +8,7 @@
 //
 // phi, k, ellint_1(k, phi)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 610> ellint_f_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 610> ellint_f_data = {{
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.12698681652545928955078125e0), SC_(0.17721911576221833285284471505772299979929420100157e-2) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.135477006435394287109375e0), SC_(0.17721911596893097495385621130075639520810631802367e-2) }}, 
      {{ SC_(0.177219114266335964202880859375e-2), SC_(0.22103404998779296875e0), SC_(0.17721911879842626333735727252300568988042608181058e-2) }}, 
--- a/test/ellint_k_data.ipp
+++ b/test/ellint_k_data.ipp
@ -3,7 +3,7 @@
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-   static const boost::array<boost::array<typename table_type<T>::type, 2>, 100> ellint_k_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 2>, 100> ellint_k_data = {{
      {{ SC_(-0.99042308330535888671875e0), SC_(0.3377711175347896212115917173531827081735908096628e1) }}, 
      {{ SC_(-0.936324596405029296875e0), SC_(0.24799928378892127263868582279024816073017669022263e1) }}, 
      {{ SC_(-0.931098163127899169921875e0), SC_(0.24445366497109921574142184681825951967450363552834e1) }}, 
--- a/test/ellint_pi2_data.ipp
+++ b/test/ellint_pi2_data.ipp
@ -7,7 +7,7 @@
 //
 // n, k, PI(n, k)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 500> ellint_pi2_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 500> ellint_pi2_data = {{
      {{ SC_(-0.871743316650390625e2), SC_(0.12698681652545928955078125e0), SC_(0.1674125184786922275852201144520277497358358213892e0) }}, 
      {{ SC_(-0.871743316650390625e2), SC_(0.135477006435394287109375e0), SC_(0.16743071541243053183466547814319460702264753849723e0) }}, 
      {{ SC_(-0.871743316650390625e2), SC_(0.22103404998779296875e0), SC_(0.16768328087467940131221559947745677007068360020936e0) }}, 
--- a/test/ellint_pi3_data.ipp
+++ b/test/ellint_pi3_data.ipp
@ -7,7 +7,7 @@
 //
 // n, phi, k, PI(n, phi, k)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 4>, 400> ellint_pi3_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 4>, 400> ellint_pi3_data = {{
      {{ SC_(0.97540400922298431396484375e-1), SC_(0.15321610867977142333984375e0), SC_(0.814723670482635498046875e0), SC_(0.15373203842748125370338546651780574888816846402842e0) }}, 
      {{ SC_(0.97540400922298431396484375e-1), SC_(0.1994704306125640869140625e0), SC_(0.135477006435394287109375e0), SC_(0.19975117232566753482238350513231879856319046077755e0) }}, 
      {{ SC_(0.97540400922298431396484375e-1), SC_(0.2128067910671234130859375e0), SC_(0.905791938304901123046875e0), SC_(0.21444962146028791552496083456124507126701014421723e0) }}, 
--- a/test/ellint_pi3_large_data.ipp
+++ b/test/ellint_pi3_large_data.ipp
@ -7,7 +7,7 @@
 //
 // n, phi, k, PI(n, phi, k)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 4>, 380> ellint_pi3_large_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 4>, 380> ellint_pi3_large_data = {{
      {{ SC_(-0.882951507568359375e2), SC_(-0.80491924285888671875e1), SC_(0.814723670482635498046875e0), SC_(-0.87472421400728425336727040442604900083192977041785e0) }}, 
      {{ SC_(-0.882951507568359375e2), SC_(-0.7460263729095458984375e1), SC_(0.135477006435394287109375e0), SC_(-0.82718880423302271609361236805097048706326618138613e0) }}, 
      {{ SC_(-0.882951507568359375e2), SC_(-0.729045963287353515625e1), SC_(0.905791938304901123046875e0), SC_(-0.87747551276758882959544200152954525505618423971659e0) }}, 
--- a/test/ellint_rc_data.ipp
+++ b/test/ellint_rc_data.ipp
@ -7,7 +7,7 @@
 //
 // x, y, RC(x, y)
 //
-   static const boost::array<boost::array<typename table_type<T>::type, 3>, 201> ellint_rc_data = {{
+   static const std::array<std::array<typename table_type<T>::type, 3>, 201> ellint_rc_data = {{
      {{ SC_(0.11698430441812742785454260394458960094979845402414e-30), SC_(0.1429457475085533184e20), SC_(0.41546482167023371731518451342517736095263780557582e-9) }}, 
      {{ SC_(0.60682196926171104626767727515008970841312337712241e-30), SC_(0.20031258624e11), SC_(0.11098537606275153066313383027431717728910787699004e-4) }}, 
      {{ SC_(0.75974287571611502022633594876763844865744160884209e-30), SC_(0.20657736771171195551744e23), SC_(0.10928951720653730370271800759007590309935803177545e-10) }}, 
--- a/Show More
+++ b/Show More