From f69c712d790178e4c92dd76384d1ec503c950966 Mon Sep 17 00:00:00 2001 From: jzmaddock Date: Tue, 30 Mar 2021 18:50:40 +0100 Subject: [PATCH] Fix broken link to lambert_w graph. Remove CircleCI asan tests. --- .circleci/config.yml | 45 ------------------- doc/html/index.html | 2 +- doc/html/indexes/s01.html | 10 ++--- doc/html/indexes/s02.html | 2 +- doc/html/indexes/s03.html | 2 +- doc/html/indexes/s04.html | 25 ++++++++--- doc/html/indexes/s05.html | 40 ++++++++++++----- doc/html/math.css | 2 + doc/html/math_toolkit/barycentric.html | 4 +- doc/html/math_toolkit/brent_minima.html | 26 +++++------ doc/html/math_toolkit/constants.html | 23 ++++++++++ doc/html/math_toolkit/conventions.html | 2 +- doc/html/math_toolkit/error_handling.html | 6 +++ .../factorials/sf_double_factorial.html | 2 +- .../math_toolkit/factorials/sf_factorial.html | 2 +- doc/html/math_toolkit/internals/cf.html | 10 ++--- .../math_toolkit/internals/error_test.html | 2 +- .../math_toolkit/internals/recurrence.html | 8 ++-- .../internals/series_evaluation.html | 14 +++--- .../math_toolkit/internals/test_data.html | 2 +- doc/html/math_toolkit/lambert_w.html | 6 +-- doc/html/math_toolkit/naive_monte_carlo.html | 15 +++++-- doc/html/math_toolkit/navigation.html | 2 +- .../math_toolkit/number_series/primes.html | 4 +- doc/html/math_toolkit/rational.html | 16 +++---- doc/html/math_toolkit/rationale.html | 2 +- .../root_finding_examples/5th_root_eg.html | 4 +- .../root_finding_examples/cbrt_eg.html | 14 +++--- .../root_finding_examples/elliptic_eg.html | 20 ++++----- .../root_finding_examples/lambda.html | 2 +- .../multiprecision_root.html | 2 +- .../root_finding_examples/nth_root.html | 14 +++--- doc/html/math_toolkit/roots_deriv.html | 8 ++-- doc/html/math_toolkit/roots_noderiv.html | 16 +++---- .../math_toolkit/roots_noderiv/TOMS748.html | 8 ++-- .../math_toolkit/roots_noderiv/bisect.html | 4 +- .../roots_noderiv/bracket_solve.html | 4 +- .../special_tut/special_tut_test.html | 20 ++++----- doc/sf/lambert_w.qbk | 2 +- 39 files changed, 209 insertions(+), 183 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 53fd40a8d..d77b8b620 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -55,53 +55,8 @@ jobs: name: Running Inspect command: | cd $BOOST_REMOVE && ../../dist/bin/inspect -text - asan_sf: - environment: - - BOOST_LIBRARY=math - - CXX_STANDARD=gnu++17 - docker: - - image: gcc:9 - steps: - - checkout - - run: - name: Setting up Environment - command: | - echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV - if [ $CIRCLE_BRANCH = "master" ]; then - echo 'export BOOST_BRANCH="master"' >> $BASH_ENV; - else - echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV; - fi - echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV - HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g') - echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV - - run: - name: install pre dependencies - command: | - apt-get update -yqq - apt-get install git libmpfr-dev libgmp-dev -y - - run: - name: Initializing git repo for boost - command: | - echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD - mkdir $BOOST - cd $BOOST - git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git - cd boost - git submodule update --init --merge - rm -rf $BOOST_REMOVE - mv $HOME/project $BOOST_REMOVE - - run: - name: Bootstrapping boost-build - command: | - cd $BOOST/boost && ./bootstrap.sh && ./b2 headers - - run: - name: Building SF ASAN Tests - command: | - cd $BOOST/boost/libs/math/test && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxstd=17 cxxstd-dialect=gnu special_fun cxxflags=-fsanitize=address linkflags=-fsanitize=address workflows: version: 2 build_and_test: jobs: - inspect - - asan_sf diff --git a/doc/html/index.html b/doc/html/index.html index 3201f75f0..f930626cd 100644 --- a/doc/html/index.html +++ b/doc/html/index.html @@ -134,7 +134,7 @@ This manual is also available in -

Last revised: February 28, 2021 at 11:38:42 GMT

+

Last revised: March 30, 2021 at 17:44:57 GMT

diff --git a/doc/html/indexes/s01.html b/doc/html/indexes/s01.html index 81d589eb0..674fd20ff 100644 --- a/doc/html/indexes/s01.html +++ b/doc/html/indexes/s01.html @@ -24,7 +24,7 @@

-Function Index

+Function Index

1 2 4 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

@@ -376,6 +376,10 @@
  • +

    BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS

    +
    +
    • +

  • bracket_and_solve_root

  • -

    set

    -
    -
    • -

  • set_zero

    • diff --git a/doc/html/indexes/s02.html b/doc/html/indexes/s02.html index 7b763827f..de7348e8d 100644 --- a/doc/html/indexes/s02.html +++ b/doc/html/indexes/s02.html @@ -24,7 +24,7 @@

    -Class Index

    +Class Index

    A B C D E F G H I K L M N O P Q R S T U V W

    diff --git a/doc/html/indexes/s03.html b/doc/html/indexes/s03.html index 66f0f04ab..6c570fcb3 100644 --- a/doc/html/indexes/s03.html +++ b/doc/html/indexes/s03.html @@ -24,7 +24,7 @@

    -Typedef Index

    +Typedef Index

    A B C D E F G H I K L N P R S T U V W

    diff --git a/doc/html/indexes/s04.html b/doc/html/indexes/s04.html index 1e5ffe686..3d40d41e5 100644 --- a/doc/html/indexes/s04.html +++ b/doc/html/indexes/s04.html @@ -24,7 +24,7 @@

    -Macro Index

    +Macro Index

    B F

    @@ -100,6 +100,25 @@
  • +

    BOOST_JOIN

    +
    +
    • +
  • +

    BOOST_MATH_ASSERT

    +
    +
    • +

  • BOOST_MATH_ASSERT_UNDEFINED_POLICY

  • -

    BOOST_MATH_BUGGY_LARGE_FLOAT_CONSTANTS

    -
    -
    • -

  • BOOST_MATH_CONTROL_FP

    • diff --git a/doc/html/indexes/s05.html b/doc/html/indexes/s05.html index 912900ce9..e06c70a53 100644 --- a/doc/html/indexes/s05.html +++ b/doc/html/indexes/s05.html @@ -23,7 +23,7 @@

    -Index

    +Index

    1 2 4 5 7 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

    @@ -498,6 +498,7 @@

  • accuracy

  • arcsine

  • arcsine_distribution

    • +

  • BOOST_MATH_ASSERT

  • cdf

  • expression

  • pdf

    • @@ -854,6 +855,7 @@

  • Binomial Quiz Example

      +

    • BOOST_MATH_ASSERT

    • BOOST_MATH_DISCRETE_QUANTILE_POLICY

    • constants

    • function

      • @@ -914,7 +916,6 @@

      Boost.Math Macros

    • @@ -4916,6 +4933,7 @@

      Graphing, Profiling, and Generating Test Data for Special Functions

      • accuracy

        • +

      • BOOST_JOIN

      • directory

      • operator

      • size

        • @@ -5134,6 +5152,7 @@

        Hyperexponential Distribution

        • accuracy

          • +

        • BOOST_MATH_ASSERT

        • constants

        • distribution

        • hyperexponential

          • @@ -5589,6 +5608,7 @@

          • accuracy

          • assert

            • +

          • BOOST_MATH_ASSERT

          • case

          • constants

          • constexpr

            • @@ -7754,6 +7774,7 @@

            Polynomials

            • bool

              • +

            • BOOST_MATH_ASSERT

            • data

            • domain

            • integrate

              • @@ -8078,7 +8099,6 @@
            • @@ -8508,6 +8528,7 @@

            • Series Evaluation

            • -

              set

              -
              -
              • -

            • Setting Polices at Namespace Scope

              • BOOST_MATH_DECLARE_DISTRIBUTIONS

                • @@ -9062,6 +9079,7 @@

                Testing

                • accuracy

                  • +

                • BOOST_JOIN

                • BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS

                • BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS

                • BOOST_MATH_NO_REAL_CONCEPT_TESTS

                  • diff --git a/doc/html/math.css b/doc/html/math.css index 6d0098083..cb5ea2e75 100644 --- a/doc/html/math.css +++ b/doc/html/math.css @@ -23,6 +23,8 @@ one in libs/math/doc and one in libs/math/doc/html ONLY EVER EDIT THE FIRST OF THESE !!!! +boost-no-inspect + =============================================================================*/ /*============================================================================= diff --git a/doc/html/math_toolkit/barycentric.html b/doc/html/math_toolkit/barycentric.html index 948f67590..042e1b6af 100644 --- a/doc/html/math_toolkit/barycentric.html +++ b/doc/html/math_toolkit/barycentric.html @@ -248,13 +248,13 @@ // the abscissa value that yields 3, not zero. We pass the functor b by value to the // lambda expression since barycentric_rational is trivial to copy. // Here we're using simple bisection to find the root: - boost::uintmax_t iterations = (std::numeric_limits<boost::uintmax_t>::max)(); + std::uintmax_t iterations = (std::numeric_limits<std::uintmax_t>::max)(); double abscissa_3 = boost::math::tools::bisect([=](double x) { return b(x) - 3; }, 0.44, 1.24, boost::math::tools::eps_tolerance<double>(), iterations).first; std::cout << "Abscissa value that yields a potential of 3 = " << abscissa_3 << std::endl; std::cout << "Root was found in " << iterations << " iterations." << std::endl; // // However, we have a more efficient root finding algorithm than simple bisection: - iterations = (std::numeric_limits<boost::uintmax_t>::max)(); + iterations = (std::numeric_limits<std::uintmax_t>::max)(); abscissa_3 = boost::math::tools::bracket_and_solve_root([=](double x) { return b(x) - 3; }, 0.6, 1.2, false, boost::math::tools::eps_tolerance<double>(), iterations).first; std::cout << "Abscissa value that yields a potential of 3 = " << abscissa_3 << std::endl; std::cout << "Root was found in " << iterations << " iterations." << std::endl; diff --git a/doc/html/math_toolkit/brent_minima.html b/doc/html/math_toolkit/brent_minima.html index b2e2c70a4..84ae621db 100644 --- a/doc/html/math_toolkit/brent_minima.html +++ b/doc/html/math_toolkit/brent_minima.html @@ -37,7 +37,7 @@ std::pair<T, T> brent_find_minima(F f, T min, T max, int bits); template <class F, class T> -std::pair<T, T> brent_find_minima(F f, T min, T max, int bits, boost::uintmax_t& max_iter); +std::pair<T, T> brent_find_minima(F f, T min, T max, int bits, std::uintmax_t& max_iter);
                  @@ -267,8 +267,8 @@ to limit iterations (in case the function proves ill-behaved), and/or perhaps to trade some loss of precision for speed, for example:

                  -
                  const boost::uintmax_t maxit = 20;
-boost::uintmax_t it = maxit;
+
                  const std::uintmax_t maxit = 20;
+std::uintmax_t it = maxit;
 std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, bits, it);
 std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second
   << " after " << it << " iterations. " << std::endl;
@@ -312,8 +312,8 @@
   << " decimal digits from tolerance " << sqrt(epsilon_2)
   << std::endl;
 std::streamsize precision_4 = std::cout.precision(prec); // Save.
-const boost::uintmax_t maxit = 20;
-boost::uintmax_t it_4 = maxit;
+const std::uintmax_t maxit = 20;
+std::uintmax_t it_4 = maxit;
 std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, bits_div_2, it_4);
 std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
 std::cout << it_4 << " iterations. " << std::endl;
@@ -334,9 +334,9 @@
   << " decimal digits from tolerance " << sqrt(epsilon_4)
   << std::endl;
 std::streamsize precision_5 = std::cout.precision(prec); // Save & set.
-const boost::uintmax_t maxit = 20;
+const std::uintmax_t maxit = 20;
 
-boost::uintmax_t it_5 = maxit;
+std::uintmax_t it_5 = maxit;
 std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, bits_div_4, it_5);
 std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second
 << ", after " << it_5 << " iterations. " << std::endl;
@@ -377,8 +377,8 @@
 long double bracket_min = -4.;
 long double bracket_max = 4. / 3;
 const int bits = std::numeric_limits<long double>::digits;
-const boost::uintmax_t maxit = 20;
-boost::uintmax_t it = maxit;
+const std::uintmax_t maxit = 20;
+std::uintmax_t it = maxit;
 
 std::pair<long double, long double> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
 std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second
@@ -419,8 +419,8 @@
       << "\n  Displaying to std::numeric_limits<T>::digits10 " << prec << ", significant decimal digits."
       << std::endl;
 
-    const boost::uintmax_t maxit = 20;
-    boost::uintmax_t it = maxit;
+    const std::uintmax_t maxit = 20;
+    std::uintmax_t it = maxit;
     // Construct using string, not double, avoids loss of precision.
     //T bracket_min = static_cast<T>("-4");
     //T bracket_max = static_cast<T>("1.3333333333333333333333333333333333333333333333333");
@@ -546,8 +546,8 @@
 cpp_bin_float_50 bracket_max = static_cast<cpp_bin_float_50>("1.3333333333333333333333333333333333333333333333333");
 
 std::cout << "Bracketing " << bracket_min << " to " << bracket_max << std::endl;
-const boost::uintmax_t maxit = 20;
-boost::uintmax_t it = maxit; // Will be updated with actual iteration count.
+const std::uintmax_t maxit = 20;
+std::uintmax_t it = maxit; // Will be updated with actual iteration count.
 std::pair<cpp_bin_float_50, cpp_bin_float_50> r
   = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
 
diff --git a/doc/html/math_toolkit/constants.html b/doc/html/math_toolkit/constants.html
index 4eb4a1898..fc7884deb 100644
--- a/doc/html/math_toolkit/constants.html
+++ b/doc/html/math_toolkit/constants.html
@@ -472,6 +472,29 @@
             
 
 
+
+              
                  
+                tau
+              
                  
+            
+
+              
                  
+                τ
+              
                  
+            
+
+              
                  
+                6.28318
+              
                  
+            
+
+              
                  
+                @https://en.wikipedia.org/wiki/Turn_(angle)#Tau_proposals Many uses,
+                most simply, circumference of a circle. Equal to two_pi.
+              
                  
+            
+
+
 
               
                  
                 two_thirds_pi
diff --git a/doc/html/math_toolkit/conventions.html b/doc/html/math_toolkit/conventions.html
index a994cbbb8..17177b15c 100644
--- a/doc/html/math_toolkit/conventions.html
+++ b/doc/html/math_toolkit/conventions.html
@@ -27,7 +27,7 @@
 Document Conventions

            - +

            This documentation aims to use of the following naming and formatting conventions. diff --git a/doc/html/math_toolkit/error_handling.html b/doc/html/math_toolkit/error_handling.html index 7db3fc48b..facad0053 100644 --- a/doc/html/math_toolkit/error_handling.html +++ b/doc/html/math_toolkit/error_handling.html @@ -53,6 +53,12 @@ will not see the message!

          +

          + The default behavior is for exceptions to be thrown using boost::throw_exception. + This facility has special handling for exception free environments. If BOOST_MATH_STANDALONE + is defined standard library facilities (e.g. throw) are used for exception + handling. +

          The kinds of errors that can be raised are:

          diff --git a/doc/html/math_toolkit/factorials/sf_double_factorial.html b/doc/html/math_toolkit/factorials/sf_double_factorial.html index 8a5ce9aca..ebfe6075d 100644 --- a/doc/html/math_toolkit/factorials/sf_double_factorial.html +++ b/doc/html/math_toolkit/factorials/sf_double_factorial.html @@ -85,7 +85,7 @@ The source code static_assert and comment just after the will be:

          -
          static_assert(!boost::is_integral<T>::value);
+
          static_assert(!std::is_integral<T>::value, "Type T must not be an integral type");
 // factorial<unsigned int>(n) is not implemented
 // because it would overflow integral type T for too small n
 // to be useful. Use instead a floating-point type,
diff --git a/doc/html/math_toolkit/factorials/sf_factorial.html b/doc/html/math_toolkit/factorials/sf_factorial.html
index 6e76cf631..7bfcc54aa 100644
--- a/doc/html/math_toolkit/factorials/sf_factorial.html
+++ b/doc/html/math_toolkit/factorials/sf_factorial.html
@@ -87,7 +87,7 @@
           The source code static_assert
           and comment just after the will be:
         
          
-
          static_assert(!boost::is_integral<T>::value);
+
          static_assert(!std::is_integral<T>::value, "Type T must not be an integral type");
 // factorial<unsigned int>(n) is not implemented
 // because it would overflow integral type T for too small n
 // to be useful. Use instead a floating-point type,
diff --git a/doc/html/math_toolkit/internals/cf.html b/doc/html/math_toolkit/internals/cf.html
index 450e37dec..5b84395c3 100644
--- a/doc/html/math_toolkit/internals/cf.html
+++ b/doc/html/math_toolkit/internals/cf.html
@@ -36,7 +36,7 @@
 
 template <class Gen, class U>
 typename detail::fraction_traits<Gen>::result_type
-   continued_fraction_b(Gen& g, const U& tolerance, boost::uintmax_t& max_terms)
+   continued_fraction_b(Gen& g, const U& tolerance, std::uintmax_t& max_terms)
 
 template <class Gen, class U>
 typename detail::fraction_traits<Gen>::result_type
@@ -44,7 +44,7 @@
 
 template <class Gen, class U>
 typename detail::fraction_traits<Gen>::result_type
-   continued_fraction_a(Gen& g, const U& tolerance, boost::uintmax_t& max_terms)
+   continued_fraction_a(Gen& g, const U& tolerance, std::uintmax_t& max_terms)
 
 template <class Gen, class U>
 typename detail::fraction_traits<Gen>::result_type
@@ -59,7 +59,7 @@
 
 template <class Gen>
 typename detail::fraction_traits<Gen>::result_type
-   continued_fraction_b(Gen& g, int bits, boost::uintmax_t& max_terms);
+   continued_fraction_b(Gen& g, int bits, std::uintmax_t& max_terms);
 
 template <class Gen>
 typename detail::fraction_traits<Gen>::result_type
@@ -67,7 +67,7 @@
 
 template <class Gen>
 typename detail::fraction_traits<Gen>::result_type
-   continued_fraction_a(Gen& g, int bits, boost::uintmax_t& max_terms);
+   continued_fraction_a(Gen& g, int bits, std::uintmax_t& max_terms);
 
 }}} // namespaces
 
          
@@ -305,7 +305,7 @@
 
          template <class T>
 inline std::complex<T> expint_as_fraction(unsigned n, std::complex<T> const& z)
 {
-   boost::uintmax_t max_iter = 1000;
+   std::uintmax_t max_iter = 1000;
    expint_fraction<std::complex<T> > f(n, z);
    std::complex<T> result = boost::math::tools::continued_fraction_b(
       f,
diff --git a/doc/html/math_toolkit/internals/error_test.html b/doc/html/math_toolkit/internals/error_test.html
index b9451b6a3..7e9f718eb 100644
--- a/doc/html/math_toolkit/internals/error_test.html
+++ b/doc/html/math_toolkit/internals/error_test.html
@@ -113,7 +113,7 @@
 
          
               Returns the mean error found.
             
          
-
          boost::uintmax_t count()const;
          
+
          std::uintmax_t count()const;
          
 
          
               Returns the number of test cases.
             
          
diff --git a/doc/html/math_toolkit/internals/recurrence.html b/doc/html/math_toolkit/internals/recurrence.html
index 93b76c4b1..aaf3cac86 100644
--- a/doc/html/math_toolkit/internals/recurrence.html
+++ b/doc/html/math_toolkit/internals/recurrence.html
@@ -36,10 +36,10 @@
 
          namespace boost{ namespace math{ namespace tools{
 
 template <class Recurrence, class T>
-T function_ratio_from_backwards_recurrence(const Recurrence& r, const T& factor, boost::uintmax_t& max_iter);
+T function_ratio_from_backwards_recurrence(const Recurrence& r, const T& factor, std::uintmax_t& max_iter);
 
 template <class Recurrence, class T>
-T function_ratio_from_forwards_recurrence(const Recurrence& r, const T& factor, boost::uintmax_t& max_iter);
+T function_ratio_from_forwards_recurrence(const Recurrence& r, const T& factor, std::uintmax_t& max_iter);
 
 template <class NextCoefs, class T>
 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);
@@ -108,7 +108,7 @@
         The tools are then as follows:
       
          
 
          template <class Recurrence, class T>
-T function_ratio_from_backwards_recurrence(const Recurrence& r, const T& factor, boost::uintmax_t& max_iter);
+T function_ratio_from_backwards_recurrence(const Recurrence& r, const T& factor, std::uintmax_t& max_iter);
 
          
 
          
         Given a functor r which encodes
@@ -133,7 +133,7 @@
         fraction.
       
          
 
          template <class Recurrence, class T>
-T function_ratio_from_forwards_recurrence(const Recurrence& r, const T& factor, boost::uintmax_t& max_iter);
+T function_ratio_from_forwards_recurrence(const Recurrence& r, const T& factor, std::uintmax_t& max_iter);
 
          
 
          
         Given a functor r which encodes
diff --git a/doc/html/math_toolkit/internals/series_evaluation.html b/doc/html/math_toolkit/internals/series_evaluation.html
index 27274eb37..444b3bea7 100644
--- a/doc/html/math_toolkit/internals/series_evaluation.html
+++ b/doc/html/math_toolkit/internals/series_evaluation.html
@@ -35,10 +35,10 @@
 
          namespace boost{ namespace math{ namespace tools{
 
 template <class Functor, class U, class V>
-inline typename Functor::result_type sum_series(Functor& func, const U& tolerance, boost::uintmax_t& max_terms, const V& init_value);
+inline typename Functor::result_type sum_series(Functor& func, const U& tolerance, std::uintmax_t& max_terms, const V& init_value);
 
 template <class Functor, class U, class V>
-inline typename Functor::result_type sum_series(Functor& func, const U& tolerance, boost::uintmax_t& max_terms);
+inline typename Functor::result_type sum_series(Functor& func, const U& tolerance, std::uintmax_t& max_terms);
 
 //
 // The following interfaces are now deprecated:
@@ -47,19 +47,19 @@
 typename Functor::result_type sum_series(Functor& func, int bits);
 
 template <class Functor>
-typename Functor::result_type sum_series(Functor& func, int bits, boost::uintmax_t& max_terms);
+typename Functor::result_type sum_series(Functor& func, int bits, std::uintmax_t& max_terms);
 
 template <class Functor, class U>
 typename Functor::result_type sum_series(Functor& func, int bits, U init_value);
 
 template <class Functor, class U>
-typename Functor::result_type sum_series(Functor& func, int bits, boost::uintmax_t& max_terms, U init_value);
+typename Functor::result_type sum_series(Functor& func, int bits, std::uintmax_t& max_terms, U init_value);
 
 template <class Functor>
 typename Functor::result_type kahan_sum_series(Functor& func, int bits);
 
 template <class Functor>
-typename Functor::result_type kahan_sum_series(Functor& func, int bits, boost::uintmax_t& max_terms);
+typename Functor::result_type kahan_sum_series(Functor& func, int bits, std::uintmax_t& max_terms);
 
 }}} // namespaces
 
          
@@ -177,7 +177,7 @@
    // Construct the series functor:
    log1p_series<T> s(x);
    // Set a limit on how many iterations we permit:
-   boost::uintmax_t max_iter = 1000;
+   std::uintmax_t max_iter = 1000;
    // Add it up, with enough precision for full machine precision:
    return boost::math::tools::sum_series(s, std::numeric_limits<T>::epsilon(), max_iter);
 }
@@ -223,7 +223,7 @@
    // Construct the series functor:
    log1p_series<std::complex<T> > s(x);
    // Set a limit on how many iterations we permit:
-   boost::uintmax_t max_iter = 1000;
+   std::uintmax_t max_iter = 1000;
    // Add it up, with enough precision for full machine precision:
    return boost::math::tools::sum_series(s, std::complex<T>(std::numeric_limits<T>::epsilon()), max_iter);
 }
diff --git a/doc/html/math_toolkit/internals/test_data.html b/doc/html/math_toolkit/internals/test_data.html
index db7be1f98..0683c2ea1 100644
--- a/doc/html/math_toolkit/internals/test_data.html
+++ b/doc/html/math_toolkit/internals/test_data.html
@@ -450,7 +450,7 @@
       //
       // Now get the approximation at double precision, along with the number of
       // iterations required:
-      boost::uintmax_t iters = std::numeric_limits<boost::uintmax_t>::max();
+      std::uintmax_t iters = std::numeric_limits<std::uintmax_t>::max();
       upper_incomplete_gamma_fract<T> f2(val, val);
       T found_val = continued_fraction_a(f2, std::numeric_limits<T>::digits, iters);
       //
diff --git a/doc/html/math_toolkit/lambert_w.html b/doc/html/math_toolkit/lambert_w.html
index 234e327b3..1ea59c6c1 100644
--- a/doc/html/math_toolkit/lambert_w.html
+++ b/doc/html/math_toolkit/lambert_w.html
@@ -80,7 +80,7 @@

        - +

        @@ -1402,8 +1402,8 @@ if (f(w) / f'(w

        The arrays are as const and constexpr and static - as possible (for the compiler version), using static constexpr. - (See lambert_w_lookup_table_generator.cpp + as possible (for the compiler version), using static constexpr macro. (See + lambert_w_lookup_table_generator.cpp The precision was chosen to ensure that if used as long double arrays, then the values output to lambert_w_lookup_table.ipp diff --git a/doc/html/math_toolkit/naive_monte_carlo.html b/doc/html/math_toolkit/naive_monte_carlo.html index 0a5a72a93..ef491bb10 100644 --- a/doc/html/math_toolkit/naive_monte_carlo.html +++ b/doc/html/math_toolkit/naive_monte_carlo.html @@ -33,7 +33,8 @@ 

        #include <boost/math/quadrature/naive_monte_carlo.hpp>
 namespace boost { namespace math { namespace quadrature {
 
-template<class Real, class F, class RNG = std::mt19937_64, class Policy = boost::math::policies::policy<>>
+template<class Real, class F, class RNG = std::mt19937_64, class Policy = boost::math::policies::policy<>,
+         typename std::enable_if<std::is_trivially_copyable<Real>::value, bool>::type = true>
 class naive_monte_carlo
 {
 public:
@@ -127,9 +128,15 @@
 
        
       First off, we define the function we wish to integrate. This function must
       accept a std::vector<Real> const &,
-      and return a Real. Next, we
-      define the domain of integration. Infinite domains are indicated by the bound
-      std::numeric_limits<Real>::infinity().
+      and return a Real.
+    
        
+
        
+      Nota bene: Real
+      must be a trivially copyable type.
+    
        
+
        
+      Next, we define the domain of integration. Infinite domains are indicated by
+      the bound std::numeric_limits<Real>::infinity().
       The call
     
        
 
        naive_monte_carlo<double, decltype(g)> mc(g, bounds, error_goal);
diff --git a/doc/html/math_toolkit/navigation.html b/doc/html/math_toolkit/navigation.html
index 637e8f5ed..dc305c118 100644
--- a/doc/html/math_toolkit/navigation.html
+++ b/doc/html/math_toolkit/navigation.html
@@ -27,7 +27,7 @@
 Navigation

    - +

    Boost.Math documentation is provided in both HTML and PDF formats. diff --git a/doc/html/math_toolkit/number_series/primes.html b/doc/html/math_toolkit/number_series/primes.html index 186f6eccf..1c9afbf8b 100644 --- a/doc/html/math_toolkit/number_series/primes.html +++ b/doc/html/math_toolkit/number_series/primes.html @@ -35,9 +35,9 @@ 

    namespace boost { namespace math {
 
 template <class Policy>
-constexpr boost::uint32_t prime(unsigned n, const Policy& pol);
+constexpr std::uint32_t prime(unsigned n, const Policy& pol);
 
-constexpr boost::uint32_t prime(unsigned n);
+constexpr std::uint32_t prime(unsigned n);
 
 static const unsigned max_prime = 10000;
 
diff --git a/doc/html/math_toolkit/rational.html b/doc/html/math_toolkit/rational.html
index 01ea6d6ea..35398ca8d 100644
--- a/doc/html/math_toolkit/rational.html
+++ b/doc/html/math_toolkit/rational.html
@@ -38,7 +38,7 @@
 V evaluate_polynomial(const T(&poly)[N], const V& val);
 
 template <std::size_t N, class T, class V>
-V evaluate_polynomial(const boost::array<T,N>& poly, const V& val);
+V evaluate_polynomial(const std::array<T,N>& poly, const V& val);
 
 template <class T, class U>
 U evaluate_polynomial(const T* poly, U z, std::size_t count);
@@ -48,7 +48,7 @@
 V evaluate_even_polynomial(const T(&poly)[N], const V& z);
 
 template <std::size_t N, class T, class V>
-V evaluate_even_polynomial(const boost::array<T,N>& poly, const V& z);
+V evaluate_even_polynomial(const std::array<T,N>& poly, const V& z);
 
 template <class T, class U>
 U evaluate_even_polynomial(const T* poly, U z, std::size_t count);
@@ -58,7 +58,7 @@
 V evaluate_odd_polynomial(const T(&a)[N], const V& z);
 
 template <std::size_t N, class T, class V>
-V evaluate_odd_polynomial(const boost::array<T,N>& a, const V& z);
+V evaluate_odd_polynomial(const std::array<T,N>& a, const V& z);
 
 template <class T, class U>
 U evaluate_odd_polynomial(const T* poly, U z, std::size_t count);
@@ -68,7 +68,7 @@
 V evaluate_rational(const T(&a)[N], const T(&b)[N], const V& z);
 
 template <std::size_t N, class T, class V>
-V evaluate_rational(const boost::array<T,N>& a, const boost::array<T,N>& b, const V& z);
+V evaluate_rational(const std::array<T,N>& a, const std::array<T,N>& b, const V& z);
 
 template <class T, class U, class V>
 V evaluate_rational(const T* num, const U* denom, V z, unsigned count);
@@ -91,7 +91,7 @@
 V evaluate_polynomial(const T(&poly)[N], const V& val);
 
 template <std::size_t N, class T, class V>
-V evaluate_polynomial(const boost::array<T,N>& poly, const V& val);
+V evaluate_polynomial(const std::array<T,N>& poly, const V& val);
 
 template <class T, class U>
 U evaluate_polynomial(const T* poly, U z, std::size_t count);
@@ -120,7 +120,7 @@
 V evaluate_even_polynomial(const T(&poly)[N], const V& z);
 
 template <std::size_t N, class T, class V>
-V evaluate_even_polynomial(const boost::array<T,N>& poly, const V& z);
+V evaluate_even_polynomial(const std::array<T,N>& poly, const V& z);
 
 template <class T, class U>
 U evaluate_even_polynomial(const T* poly, U z, std::size_t count);
@@ -134,7 +134,7 @@
 V evaluate_odd_polynomial(const T(&a)[N], const V& z);
 
 template <std::size_t N, class T, class V>
-V evaluate_odd_polynomial(const boost::array<T,N>& a, const V& z);
+V evaluate_odd_polynomial(const std::array<T,N>& a, const V& z);
 
 template <class T, class U>
 U evaluate_odd_polynomial(const T* poly, U z, std::size_t count);
@@ -148,7 +148,7 @@
 V evaluate_rational(const T(&num)[N], const U(&denom)[N], const V& z);
 
 template <std::size_t N, class T, class U, class V>
-V evaluate_rational(const boost::array<T,N>& num, const boost::array<U,N>& denom, const V& z);
+V evaluate_rational(const std::array<T,N>& num, const std::array<U,N>& denom, const V& z);
 
 template <class T, class U, class V>
 V evaluate_rational(const T* num, const U* denom, V z, unsigned count);
diff --git a/doc/html/math_toolkit/rationale.html b/doc/html/math_toolkit/rationale.html
index 1f68b4be1..7bd62bad0 100644
--- a/doc/html/math_toolkit/rationale.html
+++ b/doc/html/math_toolkit/rationale.html
@@ -35,7 +35,7 @@
       is made to automatically detect the presence of built-in floating-point types
       having specified widths. An unequivocal test requiring conformance with IEEE_floating_point
       (IEC599) based on std::numeric_limits<>::is_iec559
-      is performed with static_assert.
+      is performed with static_assert.
     
    
 
    
       In addition, this Boost implementation <boost/cstdfloat.hpp>
diff --git a/doc/html/math_toolkit/root_finding_examples/5th_root_eg.html b/doc/html/math_toolkit/root_finding_examples/5th_root_eg.html
index 7ba0a9193..a9be17b96 100644
--- a/doc/html/math_toolkit/root_finding_examples/5th_root_eg.html
+++ b/doc/html/math_toolkit/root_finding_examples/5th_root_eg.html
@@ -136,8 +136,8 @@
   T max = ldexp(2., exponent / 5);      // Maximum possible value is twice our guess.
   // Stop when slightly more than one of the digits are correct:
   const int digits = static_cast<int>(std::numeric_limits<T>::digits * 0.4);
-  const boost::uintmax_t maxit = 50;
-  boost::uintmax_t it = maxit;
+  const std::uintmax_t maxit = 50;
+  std::uintmax_t it = maxit;
   T result = halley_iterate(fifth_functor_2deriv<T>(x), guess, min, max, digits, it);
   return result;
 }
diff --git a/doc/html/math_toolkit/root_finding_examples/cbrt_eg.html b/doc/html/math_toolkit/root_finding_examples/cbrt_eg.html
index f0acb876d..307971d97 100644
--- a/doc/html/math_toolkit/root_finding_examples/cbrt_eg.html
+++ b/doc/html/math_toolkit/root_finding_examples/cbrt_eg.html
@@ -127,8 +127,8 @@
   T guess = ldexp(1., exponent/3);              // Rough guess is to divide the exponent by three.
   T factor = 2;                                 // How big steps to take when searching.
 
-  const boost::uintmax_t maxit = 20;            // Limit to maximum iterations.
-  boost::uintmax_t it = maxit;                  // Initially our chosen max iterations, but updated with actual.
+  const std::uintmax_t maxit = 20;            // Limit to maximum iterations.
+  std::uintmax_t it = maxit;                  // Initially our chosen max iterations, but updated with actual.
   bool is_rising = true;                        // So if result if guess^3 is too low, then try increasing guess.
   int digits = std::numeric_limits<T>::digits;  // Maximum possible binary digits accuracy for type T.
   // Some fraction of digits is used to control how accurate to try to make the result.
@@ -150,9 +150,9 @@
 
 
    
           The final parameter specifying a maximum number of iterations is optional.
-          However, it defaults to boost::uintmax_t
+          However, it defaults to std::uintmax_t
           maxit =
-          (std::numeric_limits<boost::uintmax_t>::max)(); which is 18446744073709551615
+          (std::numeric_limits<std::uintmax_t>::max)(); which is 18446744073709551615
           and is more than anyone would wish to wait for!
         
    
 
    
@@ -293,8 +293,8 @@
   const int digits = std::numeric_limits<T>::digits;  // Maximum possible binary digits accuracy for type T.
   int get_digits = static_cast<int>(digits * 0.6);    // Accuracy doubles with each step, so stop when we have
                                                       // just over half the digits correct.
-  const boost::uintmax_t maxit = 20;
-  boost::uintmax_t it = maxit;
+  const std::uintmax_t maxit = 20;
+  std::uintmax_t it = maxit;
   T result = newton_raphson_iterate(cbrt_functor_deriv<T>(x), guess, min, max, get_digits, it);
   return result;
 }
@@ -409,7 +409,7 @@ and reusing it, omits error handling, and does not handle negative values
   // digits used to control how accurate to try to make the result.
   int get_digits = static_cast<int>(digits * 0.4);    // Accuracy triples with each step, so stop when just
                                                       // over one third of the digits are correct.
-  boost::uintmax_t maxit = 20;
+  std::uintmax_t maxit = 20;
   T result = halley_iterate(cbrt_functor_2deriv<T>(x), guess, min, max, get_digits, maxit);
   return result;
 }
diff --git a/doc/html/math_toolkit/root_finding_examples/elliptic_eg.html b/doc/html/math_toolkit/root_finding_examples/elliptic_eg.html
index a0b46ee02..dd0377896 100644
--- a/doc/html/math_toolkit/root_finding_examples/elliptic_eg.html
+++ b/doc/html/math_toolkit/root_finding_examples/elliptic_eg.html
@@ -90,8 +90,8 @@
    T guess = sqrt(arc * arc / 16 - radius * radius);
    T factor = 1.2;                     // How big steps to take when searching.
 
-   const boost::uintmax_t maxit = 50;  // Limit to maximum iterations.
-   boost::uintmax_t it = maxit;        // Initially our chosen max iterations, but updated with actual.
+   const std::uintmax_t maxit = 50;  // Limit to maximum iterations.
+   std::uintmax_t it = maxit;        // Initially our chosen max iterations, but updated with actual.
    bool is_rising = true;              // arc-length increases if one radii increases, so function is rising
    // Define a termination condition, stop when nearly all digits are correct, but allow for
    // the fact that we are returning a range, and must have some inaccuracy in the elliptic integral:
@@ -123,7 +123,7 @@
 
    template <class T = double>
 struct elliptic_root_functor_1deriv
 { // Functor also returning 1st derivative.
-   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
+   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
 
    elliptic_root_functor_1deriv(T const& arc, T const& radius) : m_arc(arc), m_radius(radius)
    { // Constructor just stores value a to find root of.
@@ -162,7 +162,7 @@
    using namespace std;  // Help ADL of std functions.
    using namespace boost::math::tools; // For newton_raphson_iterate.
 
-   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
+   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
 
    T guess = sqrt(arc * arc / 16 - radius * radius);
    T min = 0;   // Minimum possible value is zero.
@@ -171,8 +171,8 @@
    // Accuracy doubles at each step, so stop when just over half of the digits are
    // correct, and rely on that step to polish off the remainder:
    int get_digits = static_cast<int>(std::numeric_limits<T>::digits * 0.6);
-   const boost::uintmax_t maxit = 20;
-   boost::uintmax_t it = maxit;
+   const std::uintmax_t maxit = 20;
+   std::uintmax_t it = maxit;
    T result = newton_raphson_iterate(elliptic_root_functor_1deriv<T>(arc, radius), guess, min, max, get_digits, it);
    return result;
 } // T elliptic_root_1_deriv  Newton-Raphson
@@ -192,7 +192,7 @@
 
    template <class T = double>
 struct elliptic_root_functor_2deriv
 { // Functor returning both 1st and 2nd derivatives.
-   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
+   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
 
    elliptic_root_functor_2deriv(T const& arc, T const& radius) : m_arc(arc), m_radius(radius) {}
    std::tuple<T, T, T> operator()(T const& x)
@@ -229,7 +229,7 @@
    using namespace std;                // Help ADL of std functions.
    using namespace boost::math::tools; // For halley_iterate.
 
-   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
+   static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
 
    T guess = sqrt(arc * arc / 16 - radius * radius);
    T min = 0;                                   // Minimum possible value is zero.
@@ -238,8 +238,8 @@
    // Accuracy triples at each step, so stop when just over one-third of the digits
    // are correct, and the last iteration will polish off the remaining digits:
    int get_digits = static_cast<int>(std::numeric_limits<T>::digits * 0.4);
-   const boost::uintmax_t maxit = 20;
-   boost::uintmax_t it = maxit;
+   const std::uintmax_t maxit = 20;
+   std::uintmax_t it = maxit;
    T result = halley_iterate(elliptic_root_functor_2deriv<T>(arc, radius), guess, min, max, get_digits, it);
    return result;
 } // nth_2deriv Halley
diff --git a/doc/html/math_toolkit/root_finding_examples/lambda.html b/doc/html/math_toolkit/root_finding_examples/lambda.html
index a77c558ed..a5d484b08 100644
--- a/doc/html/math_toolkit/root_finding_examples/lambda.html
+++ b/doc/html/math_toolkit/root_finding_examples/lambda.html
@@ -47,7 +47,7 @@
    // digits used to control how accurate to try to make the result.
    int get_digits = static_cast<int>(digits * 0.4);    // Accuracy triples with each step, so stop when just
    // over one third of the digits are correct.
-   boost::uintmax_t maxit = 20;
+   std::uintmax_t maxit = 20;
    T result = halley_iterate(
       // lambda function:
       [x](const T& g){ return std::make_tuple(g * g * g - x, 3 * g * g, 6 * g); },
diff --git a/doc/html/math_toolkit/root_finding_examples/multiprecision_root.html b/doc/html/math_toolkit/root_finding_examples/multiprecision_root.html
index 6d00be9e7..fb62f5f30 100644
--- a/doc/html/math_toolkit/root_finding_examples/multiprecision_root.html
+++ b/doc/html/math_toolkit/root_finding_examples/multiprecision_root.html
@@ -150,7 +150,7 @@
    // digits used to control how accurate to try to make the result.
    int get_digits = static_cast<int>(digits * 0.4);    // Accuracy triples with each step, so stop when just
    // over one third of the digits are correct.
-   boost::uintmax_t maxit = 20;
+   std::uintmax_t maxit = 20;
    T result = halley_iterate(
       // lambda function:
       [x](const T& g){ return std::make_tuple(g * g * g - x, 3 * g * g, 6 * g); },
diff --git a/doc/html/math_toolkit/root_finding_examples/nth_root.html b/doc/html/math_toolkit/root_finding_examples/nth_root.html
index 4e2ab00f2..b40fb8da9 100644
--- a/doc/html/math_toolkit/root_finding_examples/nth_root.html
+++ b/doc/html/math_toolkit/root_finding_examples/nth_root.html
@@ -53,8 +53,8 @@
 
    template <int N, class T = double>
 struct nth_functor_2deriv
 { // Functor returning both 1st and 2nd derivatives.
-  static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
-  static_assert((N > 0) == true, "root N must be > 0!");
+  static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
+  static_assert((N > 0) == true, "root N must be > 0!");
 
   nth_functor_2deriv(T const& to_find_root_of) : a(to_find_root_of)
   { /* Constructor stores value a to find root of, for example: */ }
@@ -84,9 +84,9 @@
   using namespace std;  // Help ADL of std functions.
   using namespace boost::math::tools; // For halley_iterate.
 
-  static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
-  static_assert((N > 0) == true, "root N must be > 0!");
-  static_assert((N > 1000) == false, "root N is too big!");
+  static_assert(boost::is_integral<T>::value == false, "Only floating-point type types can be used!");
+  static_assert((N > 0) == true, "root N must be > 0!");
+  static_assert((N > 1000) == false, "root N is too big!");
 
   typedef double guess_type; // double may restrict (exponent) range for a multiprecision T?
 
@@ -98,8 +98,8 @@
 
   int digits = std::numeric_limits<T>::digits * 0.4;            // Accuracy triples with each step, so stop when
                                                                 // slightly more than one third of the digits are correct.
-  const boost::uintmax_t maxit = 20;
-  boost::uintmax_t it = maxit;
+  const std::uintmax_t maxit = 20;
+  std::uintmax_t it = maxit;
   T result = halley_iterate(nth_functor_2deriv<N, T>(x), guess, min, max, digits, it);
   return result;
 }
diff --git a/doc/html/math_toolkit/roots_deriv.html b/doc/html/math_toolkit/roots_deriv.html
index 1ec5cc1cd..8830d31d1 100644
--- a/doc/html/math_toolkit/roots_deriv.html
+++ b/doc/html/math_toolkit/roots_deriv.html
@@ -40,21 +40,21 @@
 T newton_raphson_iterate(F f, T guess, T min, T max, int digits);
 
 template <class F, class T>
-T newton_raphson_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter);
+T newton_raphson_iterate(F f, T guess, T min, T max, int digits, std::uintmax_t& max_iter);
 
 // Halley
 template <class F, class T>
 T halley_iterate(F f, T guess, T min, T max, int digits);
 
 template <class F, class T>
-T halley_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter);
+T halley_iterate(F f, T guess, T min, T max, int digits, std::uintmax_t& max_iter);
 
 // Schr'''&#xf6;'''der
 template <class F, class T>
 T schroder_iterate(F f, T guess, T min, T max, int digits);
 
 template <class F, class T>
-T schroder_iterate(F f, T guess, T min, T max, int digits, boost::uintmax_t& max_iter);
+T schroder_iterate(F f, T guess, T min, T max, int digits, std::uintmax_t& max_iter);
 
 template <class F, class Complex>
 Complex complex_newton(F f, Complex guess, int max_iterations = std::numeric_limits<typename Complex::value_type>::digits);
@@ -146,7 +146,7 @@
 
      
 
    • 
           Default max_iter =
-          (std::numeric_limits<boost::uintmax_t>::max)() is effectively 'iterate for ever'.
+          (std::numeric_limits<std::uintmax_t>::max)() is effectively 'iterate for ever'.
         
      • 
 
    • 
           They may be very sensitive to the initial guess, typically they converge
diff --git a/doc/html/math_toolkit/roots_noderiv.html b/doc/html/math_toolkit/roots_noderiv.html
index 1cb36e1b5..c17a2b624 100644
--- a/doc/html/math_toolkit/roots_noderiv.html
+++ b/doc/html/math_toolkit/roots_noderiv.html
@@ -53,7 +53,7 @@
        T min,
        T max,
        Tol tol,
-       boost::uintmax_t& max_iter);
+       std::uintmax_t& max_iter);
 
  template <class F, class T, class Tol>
  std::pair<T, T>
@@ -70,7 +70,7 @@
        T min,
        T max,
        Tol tol,
-       boost::uintmax_t& max_iter,
+       std::uintmax_t& max_iter,
        const Policy&);
 
  // Bracket and Solve Root
@@ -82,7 +82,7 @@
        const T& factor,
        bool rising,
        Tol tol,
-       boost::uintmax_t& max_iter);
+       std::uintmax_t& max_iter);
 
  template <class F, class T, class Tol, class Policy>
  std::pair<T, T>
@@ -92,7 +92,7 @@
        const T& factor,
        bool rising,
        Tol tol,
-       boost::uintmax_t& max_iter,
+       std::uintmax_t& max_iter,
        const Policy&);
 
 // TOMS 748 algorithm
@@ -103,7 +103,7 @@
        const T& a,
        const T& b,
        Tol tol,
-       boost::uintmax_t& max_iter);
+       std::uintmax_t& max_iter);
 
  template <class F, class T, class Tol, class Policy>
  std::pair<T, T>
@@ -112,7 +112,7 @@
        const T& a,
        const T& b,
        Tol tol,
-       boost::uintmax_t& max_iter,
+       std::uintmax_t& max_iter,
        const Policy&);
 
  template <class F, class T, class Tol>
@@ -124,7 +124,7 @@
        const T& fa,
        const T& fb,
        Tol tol,
-       boost::uintmax_t& max_iter);
+       std::uintmax_t& max_iter);
 
  template <class F, class T, class Tol, class Policy>
  std::pair<T, T>
@@ -135,7 +135,7 @@
        const T& fa,
        const T& fb,
        Tol tol,
-       boost::uintmax_t& max_iter,
+       std::uintmax_t& max_iter,
        const Policy&);
 
  // Termination conditions:
diff --git a/doc/html/math_toolkit/roots_noderiv/TOMS748.html b/doc/html/math_toolkit/roots_noderiv/TOMS748.html
index 0825a5fef..f0b47a6a1 100644
--- a/doc/html/math_toolkit/roots_noderiv/TOMS748.html
+++ b/doc/html/math_toolkit/roots_noderiv/TOMS748.html
@@ -34,7 +34,7 @@
       const T& a,
       const T& b,
       Tol tol,
-      boost::uintmax_t& max_iter);
+      std::uintmax_t& max_iter);
 
 template <class F, class T, class Tol, class Policy>
 std::pair<T, T>
@@ -43,7 +43,7 @@
       const T& a,
       const T& b,
       Tol tol,
-      boost::uintmax_t& max_iter,
+      std::uintmax_t& max_iter,
       const Policy&);
 
 template <class F, class T, class Tol>
@@ -55,7 +55,7 @@
       const T& fa,
       const T& fb,
       Tol tol,
-      boost::uintmax_t& max_iter);
+      std::uintmax_t& max_iter);
 
 template <class F, class T, class Tol, class Policy>
 std::pair<T, T>
@@ -66,7 +66,7 @@
       const T& fa,
       const T& fb,
       Tol tol,
-      boost::uintmax_t& max_iter,
+      std::uintmax_t& max_iter,
       const Policy&);
 
    
 
    
diff --git a/doc/html/math_toolkit/roots_noderiv/bisect.html b/doc/html/math_toolkit/roots_noderiv/bisect.html
index e69f09717..07add7d4c 100644
--- a/doc/html/math_toolkit/roots_noderiv/bisect.html
+++ b/doc/html/math_toolkit/roots_noderiv/bisect.html
@@ -41,7 +41,7 @@
       T min,
       T max,
       Tol tol,
-      boost::uintmax_t& max_iter);
+      std::uintmax_t& max_iter);
 
 template <class F, class T, class Tol, class Policy>
 std::pair<T, T>
@@ -50,7 +50,7 @@
       T min,
       T max,
       Tol tol,
-      boost::uintmax_t& max_iter,
+      std::uintmax_t& max_iter,
       const Policy&);
 
    
 
    
diff --git a/doc/html/math_toolkit/roots_noderiv/bracket_solve.html b/doc/html/math_toolkit/roots_noderiv/bracket_solve.html
index 1520b5251..3e3ca0939 100644
--- a/doc/html/math_toolkit/roots_noderiv/bracket_solve.html
+++ b/doc/html/math_toolkit/roots_noderiv/bracket_solve.html
@@ -35,7 +35,7 @@
       const T& factor,
       bool rising,
       Tol tol,
-      boost::uintmax_t& max_iter);
+      std::uintmax_t& max_iter);
 
 template <class F, class T, class Tol, class Policy>
 std::pair<T, T>
@@ -45,7 +45,7 @@
       const T& factor,
       bool rising,
       Tol tol,
-      boost::uintmax_t& max_iter,
+      std::uintmax_t& max_iter,
       const Policy&);
 
    
 
    
diff --git a/doc/html/math_toolkit/special_tut/special_tut_test.html b/doc/html/math_toolkit/special_tut/special_tut_test.html
index abe167acf..0a1c6b3f6 100644
--- a/doc/html/math_toolkit/special_tut/special_tut_test.html
+++ b/doc/html/math_toolkit/special_tut/special_tut_test.html
@@ -103,7 +103,9 @@
         expansions etc) disabled. We have a set of tools
         to generate test data directly, here's a typical example:
       
    
-
    #include <boost/multiprecision/cpp_dec_float.hpp>
+
    #ifndef BOOST_MATH_STANDALONE
+
+#include <boost/multiprecision/cpp_dec_float.hpp>
 #include <boost/math/tools/test_data.hpp>
 #include <boost/test/included/prg_exec_monitor.hpp>
 #include <fstream>
@@ -345,15 +347,13 @@
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
    test(0.1L, "long double");
 #ifndef BOOST_MATH_NO_REAL_CONCEPT_TESTS
-#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x582))
-   test(boost::math::concepts::real_concept(0.1), "real_concept");
-#endif
-#endif
-#else
-   std::cout << "<note>The long double tests have been disabled on this platform "
-      "either because the long double overloads of the usual math functions are "
-      "not available at all, or because they are too inaccurate for these tests "
-      "to pass.</note>" << std::cout;
+   test(boost::math::concepts::real_concept(0.1), "real_concept);
+#endif
+#else
+   std::cout << "<note>The long double tests have been disabled on this platform "
+      "either because the long double overloads of the usual math functions are "
+      "not available at all, or because they are too inaccurate for these tests "
+      "to pass.</note>" << std::cout;
 #endif
 }
 
    
diff --git a/doc/sf/lambert_w.qbk b/doc/sf/lambert_w.qbk
index 76734cafb..22b13b6ac 100644
--- a/doc/sf/lambert_w.qbk
+++ b/doc/sf/lambert_w.qbk
@@ -42,7 +42,7 @@ In Boost.Math, we call these principal branches `lambert_w0` and `lambert_wm1`;
 [import ../../example/lambert_w_graph.cpp]
 
 [graph lambert_w_graph]
-[graph lambert_w_graph_big_w]
+[graph lambert_w_graph_big_W]
 [graph lambert_w0_prime_graph]
 [graph lambert_wm1_prime_graph]