Library/boost/libs/math/test/test_autodiff_2.cpp - main - BirdLeon/ROBLOX2016

Library/boost/libs/math/test/test_autodiff_2.cpp
512 строк21 KB
PatoFlamejanteTV
full source code
19 дек 2024, 19:11
19 дек 2024, 19:1105db15d
//           Copyright Matthew Pulver 2018 - 2019.
// Distributed under the Boost Software License, Version 1.0.
//      (See accompanying file LICENSE_1_0.txt or copy at
//           https://www.boost.org/LICENSE_1_0.txt)

#include "test_autodiff.hpp"

BOOST_AUTO_TEST_SUITE(test_autodiff_2)

BOOST_AUTO_TEST_CASE_TEMPLATE(one_over_one_plus_x_squared, T, all_float_types) {
  constexpr std::size_t m = 4;
  const T cx(1);
  auto f = make_fvar<T, m>(cx);
  // f = 1 / ((f *= f) += 1);
  f *= f;
  f += T(1);
  f = f.inverse();
  BOOST_CHECK_EQUAL(f.derivative(0u), 0.5);
  BOOST_CHECK_EQUAL(f.derivative(1u), -0.5);
  BOOST_CHECK_EQUAL(f.derivative(2u), 0.5);
  BOOST_CHECK_EQUAL(f.derivative(3u), 0);
  BOOST_CHECK_EQUAL(f.derivative(4u), -3);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(exp_test, T, all_float_types) {
  using std::exp;
  constexpr std::size_t m = 4;
  const T cx = 2.0;
  const auto x = make_fvar<T, m>(cx);
  auto y = exp(x);
  for (auto i : boost::irange(m + 1)) {
    // std::cout.precision(100);
    // std::cout << "y.derivative("<<i<<") = " << y.derivative(i) << ",
    // std::exp(cx) = " << std::exp(cx) << std::endl;
    BOOST_CHECK_CLOSE_FRACTION(y.derivative(i), exp(cx),
                               std::numeric_limits<T>::epsilon());
  }
}

BOOST_AUTO_TEST_CASE_TEMPLATE(pow, T, bin_float_types) {
  const T eps = 201 * std::numeric_limits<T>::epsilon(); // percent
  using std::log;
  using std::pow;
  constexpr std::size_t m = 5;
  constexpr std::size_t n = 4;
  const T cx = 2.0;
  const T cy = 3.0;
  const auto x = make_fvar<T, m>(cx);
  const auto y = make_fvar<T, m, n>(cy);
  auto z0 = pow(x, cy);
  BOOST_CHECK_EQUAL(z0.derivative(0u), pow(cx, cy));
  BOOST_CHECK_EQUAL(z0.derivative(1u), cy * pow(cx, cy - 1));
  BOOST_CHECK_EQUAL(z0.derivative(2u), cy * (cy - 1) * pow(cx, cy - 2));
  BOOST_CHECK_EQUAL(z0.derivative(3u),
                    cy * (cy - 1) * (cy - 2) * pow(cx, cy - 3));
  BOOST_CHECK_EQUAL(z0.derivative(4u), 0u);
  BOOST_CHECK_EQUAL(z0.derivative(5u), 0u);
  auto z1 = pow(cx, y);
  BOOST_CHECK_CLOSE(z1.derivative(0u, 0u), pow(cx, cy), eps);
  for (auto j : boost::irange(std::size_t(1), n + 1)) {
    BOOST_CHECK_CLOSE(z1.derivative(0u, j), pow(log(cx), j) * pow(cx, cy), eps);
  }

  for (auto i : boost::irange(std::size_t(1), m + 1)) {
    for (auto j : boost::irange(n + 1)) {
      BOOST_CHECK_EQUAL(z1.derivative(i, j), 0);
    }
  }

  const auto z2 = pow(x, y);

  for (auto j : boost::irange(n + 1)) {
    BOOST_CHECK_CLOSE(z2.derivative(0u, j), pow(cx, cy) * pow(log(cx), j), eps);
  }
  for (auto j : boost::irange(n + 1)) {
    BOOST_CHECK_CLOSE(z2.derivative(1u, j),
                      pow(cx, cy - 1) * pow(log(cx), static_cast<int>(j) - 1) *
                          (cy * log(cx) + j),
                      eps);
  }
  BOOST_CHECK_CLOSE(z2.derivative(2u, 0u), pow(cx, cy - 2) * cy * (cy - 1),
                    eps);
  BOOST_CHECK_CLOSE(z2.derivative(2u, 1u),
                    pow(cx, cy - 2) * (cy * (cy - 1) * log(cx) + 2 * cy - 1),
                    eps);
  for (auto j : boost::irange(std::size_t(2u), n + 1)) {
    BOOST_CHECK_CLOSE(z2.derivative(2u, j),
                      pow(cx, cy - 2) * pow(log(cx), j - 2) *
                          (j * (2 * cy - 1) * log(cx) + (j - 1) * j +
                           (cy - 1) * cy * pow(log(cx), 2)),
                      eps);
  }
  BOOST_CHECK_CLOSE(z2.derivative(2u, 4u),
                    pow(cx, cy - 2) * pow(log(cx), 2) *
                        (4 * (2 * cy - 1) * log(cx) + (4 - 1) * 4 +
                         (cy - 1) * cy * pow(log(cx), 2)),
                    eps);
}

// TODO Tests around x=0 or y=0: pow(x,y)
BOOST_AUTO_TEST_CASE_TEMPLATE(pow2, T, bin_float_types) {
  const T eps = 4000 * std::numeric_limits<T>::epsilon(); // percent
  using std::pow;
  constexpr std::size_t m = 5;
  constexpr std::size_t n = 5;
  const T cx = 2;
  const T cy = 5 / 2.0;
  const auto x = make_fvar<T, m>(cx);
  const auto y = make_fvar<T, 0, n>(cy);
  const auto z = pow(x, y);
  using namespace boost::math::constants;
  // Mathematica: Export["pow.csv", Flatten@Table[ Simplify@D[x^y,{x,i},{y,j}]
  // /. {x->2, y->5/2},
  //                    { i, 0, 5 }, { j, 0, 5 } ] ]
  // sed -rf pow.sed < pow.csv
  // with pow.sed script:
  // s/Log\[2\]\^([0-9]+)/pow(ln_two<T>(),\1)/g
  // s/Log\[2\]/ln_two<T>()/g
  // s/Sqrt\[2\]/root_two<T>()/g
  // s/[0-9]\/[0-9]+/\0.0/g
  // s/^"/static_cast<T>(/
  // s/"$/),/
  const T mathematica[]{
      static_cast<T>(4 * root_two<T>()),
      static_cast<T>(4 * root_two<T>() * ln_two<T>()),
      static_cast<T>(4 * root_two<T>() * pow(ln_two<T>(), 2)),
      static_cast<T>(4 * root_two<T>() * pow(ln_two<T>(), 3)),
      static_cast<T>(4 * root_two<T>() * pow(ln_two<T>(), 4)),
      static_cast<T>(4 * root_two<T>() * pow(ln_two<T>(), 5)),
      static_cast<T>(5 * root_two<T>()),
      static_cast<T>(2 * root_two<T>() * (1 + (5 * ln_two<T>()) / 2)),
      static_cast<T>(2 * root_two<T>() * ln_two<T>() *
                     (2 + (5 * ln_two<T>()) / 2)),
      static_cast<T>(2 * root_two<T>() * pow(ln_two<T>(), 2) *
                     (3 + (5 * ln_two<T>()) / 2)),
      static_cast<T>(2 * root_two<T>() * pow(ln_two<T>(), 3) *
                     (4 + (5 * ln_two<T>()) / 2)),
      static_cast<T>(2 * root_two<T>() * pow(ln_two<T>(), 4) *
                     (5 + (5 * ln_two<T>()) / 2)),
      static_cast<T>(15 / (2 * root_two<T>())),
      static_cast<T>(root_two<T>() * (4 + (15 * ln_two<T>()) / 4)),
      static_cast<T>(root_two<T>() *
                     (2 + 8 * ln_two<T>() + (15 * pow(ln_two<T>(), 2)) / 4)),
      static_cast<T>(root_two<T>() * ln_two<T>() *
                     (6 + 12 * ln_two<T>() + (15 * pow(ln_two<T>(), 2)) / 4)),
      static_cast<T>(root_two<T>() * pow(ln_two<T>(), 2) *
                     (12 + 16 * ln_two<T>() + (15 * pow(ln_two<T>(), 2)) / 4)),
      static_cast<T>(root_two<T>() * pow(ln_two<T>(), 3) *
                     (20 + 20 * ln_two<T>() + (15 * pow(ln_two<T>(), 2)) / 4)),
      static_cast<T>(15 / (8 * root_two<T>())),
      static_cast<T>((23 / 4.0 + (15 * ln_two<T>()) / 8) / root_two<T>()),
      static_cast<T>(
          (9 + (23 * ln_two<T>()) / 2 + (15 * pow(ln_two<T>(), 2)) / 8) /
          root_two<T>()),
      static_cast<T>((6 + 27 * ln_two<T>() + (69 * pow(ln_two<T>(), 2)) / 4 +
                      (15 * pow(ln_two<T>(), 3)) / 8) /
                     root_two<T>()),
      static_cast<T>(
          (ln_two<T>() * (24 + 54 * ln_two<T>() + 23 * pow(ln_two<T>(), 2) +
                          (15 * pow(ln_two<T>(), 3)) / 8)) /
          root_two<T>()),
      static_cast<T>((pow(ln_two<T>(), 2) *
                      (60 + 90 * ln_two<T>() + (115 * pow(ln_two<T>(), 2)) / 4 +
                       (15 * pow(ln_two<T>(), 3)) / 8)) /
                     root_two<T>()),
      static_cast<T>(-15 / (32 * root_two<T>())),
      static_cast<T>((-1 - (15 * ln_two<T>()) / 16) / (2 * root_two<T>())),
      static_cast<T>((7 - 2 * ln_two<T>() - (15 * pow(ln_two<T>(), 2)) / 16) /
                     (2 * root_two<T>())),
      static_cast<T>((24 + 21 * ln_two<T>() - 3 * pow(ln_two<T>(), 2) -
                      (15 * pow(ln_two<T>(), 3)) / 16) /
                     (2 * root_two<T>())),
      static_cast<T>((24 + 96 * ln_two<T>() + 42 * pow(ln_two<T>(), 2) -
                      4 * pow(ln_two<T>(), 3) -
                      (15 * pow(ln_two<T>(), 4)) / 16) /
                     (2 * root_two<T>())),
      static_cast<T>(
          (ln_two<T>() *
           (120 + 240 * ln_two<T>() + 70 * pow(ln_two<T>(), 2) -
            5 * pow(ln_two<T>(), 3) - (15 * pow(ln_two<T>(), 4)) / 16)) /
          (2 * root_two<T>())),
      static_cast<T>(45 / (128 * root_two<T>())),
      static_cast<T>((9 / 16.0 + (45 * ln_two<T>()) / 32) /
                     (4 * root_two<T>())),
      static_cast<T>((-25 / 2.0 + (9 * ln_two<T>()) / 8 +
                      (45 * pow(ln_two<T>(), 2)) / 32) /
                     (4 * root_two<T>())),
      static_cast<T>((-15 - (75 * ln_two<T>()) / 2 +
                      (27 * pow(ln_two<T>(), 2)) / 16 +
                      (45 * pow(ln_two<T>(), 3)) / 32) /
                     (4 * root_two<T>())),
      static_cast<T>((60 - 60 * ln_two<T>() - 75 * pow(ln_two<T>(), 2) +
                      (9 * pow(ln_two<T>(), 3)) / 4 +
                      (45 * pow(ln_two<T>(), 4)) / 32) /
                     (4 * root_two<T>())),
      static_cast<T>((120 + 300 * ln_two<T>() - 150 * pow(ln_two<T>(), 2) -
                      125 * pow(ln_two<T>(), 3) +
                      (45 * pow(ln_two<T>(), 4)) / 16 +
                      (45 * pow(ln_two<T>(), 5)) / 32) /
                     (4 * root_two<T>()))};
  std::size_t k = 0;
  for (auto i : boost::irange(m + 1)) {
    for (auto j : boost::irange(n + 1)) {
      BOOST_CHECK_CLOSE(z.derivative(i, j), mathematica[k++], eps);
    }
  }
}

BOOST_AUTO_TEST_CASE_TEMPLATE(sqrt_test, T, all_float_types) {
  using std::pow;
  using std::sqrt;
  constexpr std::size_t m = 5;
  const T cx = 4.0;
  auto x = make_fvar<T, m>(cx);
  auto y = sqrt(x);
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(0u), sqrt(cx),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(1u), 0.5 * pow(cx, -0.5),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(2u), -0.5 * 0.5 * pow(cx, -1.5),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(3u), 0.5 * 0.5 * 1.5 * pow(cx, -2.5),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(4u),
                             -0.5 * 0.5 * 1.5 * 2.5 * pow(cx, -3.5),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(5u),
                             0.5 * 0.5 * 1.5 * 2.5 * 3.5 * pow(cx, -4.5),
                             std::numeric_limits<T>::epsilon());
  x = make_fvar<T, m>(0);
  y = sqrt(x);
  // std::cout << "sqrt(0) = " << y << std::endl; // (0,inf,-inf,inf,-inf,inf)
  BOOST_CHECK_EQUAL(y.derivative(0u), 0);
  for (auto i : boost::irange(std::size_t(1), m + 1)) {
    BOOST_CHECK_EQUAL(y.derivative(i), (i % 2 == 1 ? 1 : -1) *
                                           std::numeric_limits<T>::infinity());
  }
}

BOOST_AUTO_TEST_CASE_TEMPLATE(log_test, T, all_float_types) {
  using std::log;
  using std::pow;
  constexpr std::size_t m = 5;
  const T cx = 2.0;
  auto x = make_fvar<T, m>(cx);
  auto y = log(x);
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(0u), log(cx),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(1u), 1 / cx,
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(2u), -1 / pow(cx, 2),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(3u), 2 / pow(cx, 3),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(4u), -6 / pow(cx, 4),
                             std::numeric_limits<T>::epsilon());
  BOOST_CHECK_CLOSE_FRACTION(y.derivative(5u), 24 / pow(cx, 5),
                             std::numeric_limits<T>::epsilon());
  x = make_fvar<T, m>(0);
  y = log(x);
  // std::cout << "log(0) = " << y << std::endl; // log(0) =
  // depth(1)(-inf,inf,-inf,inf,-inf,inf)
  for (auto i : boost::irange(m + 1)) {
    BOOST_CHECK_EQUAL(y.derivative(i), (i % 2 == 1 ? 1 : -1) *
                                           std::numeric_limits<T>::infinity());
  }
}

BOOST_AUTO_TEST_CASE_TEMPLATE(ylogx, T, all_float_types) {
  using std::log;
  using std::pow;
  const T eps = 100 * std::numeric_limits<T>::epsilon(); // percent
  constexpr std::size_t m = 5;
  constexpr std::size_t n = 4;
  const T cx = 2.0;
  const T cy = 3.0;
  const auto x = make_fvar<T, m>(cx);
  const auto y = make_fvar<T, m, n>(cy);
  auto z = y * log(x);
  BOOST_CHECK_EQUAL(z.derivative(0u, 0u), cy * log(cx));
  BOOST_CHECK_EQUAL(z.derivative(0u, 1u), log(cx));
  BOOST_CHECK_EQUAL(z.derivative(0u, 2u), 0);
  BOOST_CHECK_EQUAL(z.derivative(0u, 3u), 0);
  BOOST_CHECK_EQUAL(z.derivative(0u, 4u), 0);
  for (auto i : boost::irange(1u, static_cast<unsigned>(m + 1))) {
    BOOST_CHECK_CLOSE(z.derivative(i, 0u),
                      pow(-1, i - 1) * boost::math::factorial<T>(i - 1) * cy /
                          pow(cx, i),
                      eps);
    BOOST_CHECK_CLOSE(
        z.derivative(i, 1u),
        pow(-1, i - 1) * boost::math::factorial<T>(i - 1) / pow(cx, i), eps);
    for (auto j : boost::irange(std::size_t(2), n + 1)) {
      BOOST_CHECK_EQUAL(z.derivative(i, j), 0u);
    }
  }
  auto z1 = exp(z);
  // RHS is confirmed by
  // https://www.wolframalpha.com/input/?i=D%5Bx%5Ey,%7Bx,2%7D,%7By,4%7D%5D+%2F.+%7Bx-%3E2.0,+y-%3E3.0%7D
  BOOST_CHECK_CLOSE(z1.derivative(2u, 4u),
                    pow(cx, cy - 2) * pow(log(cx), 2) *
                        (4 * (2 * cy - 1) * log(cx) + (4 - 1) * 4 +
                         (cy - 1) * cy * pow(log(cx), 2)),
                    eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(frexp_test, T, all_float_types) {
  using std::exp2;
  using std::frexp;
  constexpr std::size_t m = 3;
  const T cx = 3.5;
  const auto x = make_fvar<T, m>(cx);
  int exp, testexp;
  auto y = frexp(x, &exp);
  BOOST_CHECK_EQUAL(y.derivative(0u), frexp(cx, &testexp));
  BOOST_CHECK_EQUAL(exp, testexp);
  BOOST_CHECK_EQUAL(y.derivative(1u), exp2(-exp));
  BOOST_CHECK_EQUAL(y.derivative(2u), 0);
  BOOST_CHECK_EQUAL(y.derivative(3u), 0);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(ldexp_test, T, all_float_types) {
  BOOST_MATH_STD_USING
  using boost::multiprecision::ldexp;
  constexpr auto m = 3u;
  const T cx = 3.5;
  const auto x = make_fvar<T, m>(cx);
  constexpr auto exponent = 3;
  auto y = ldexp(x, exponent);
  BOOST_CHECK_EQUAL(y.derivative(0u), ldexp(cx, exponent));
  BOOST_CHECK_EQUAL(y.derivative(1u), exp2(exponent));
  BOOST_CHECK_EQUAL(y.derivative(2u), 0);
  BOOST_CHECK_EQUAL(y.derivative(3u), 0);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(cos_and_sin, T, bin_float_types) {
  using std::cos;
  using std::sin;
  const T eps = 200 * std::numeric_limits<T>::epsilon(); // percent
  constexpr std::size_t m = 5;
  const T cx = boost::math::constants::third_pi<T>();
  const auto x = make_fvar<T, m>(cx);
  auto cos5 = cos(x);
  BOOST_CHECK_CLOSE(cos5.derivative(0u), cos(cx), eps);
  BOOST_CHECK_CLOSE(cos5.derivative(1u), -sin(cx), eps);
  BOOST_CHECK_CLOSE(cos5.derivative(2u), -cos(cx), eps);
  BOOST_CHECK_CLOSE(cos5.derivative(3u), sin(cx), eps);
  BOOST_CHECK_CLOSE(cos5.derivative(4u), cos(cx), eps);
  BOOST_CHECK_CLOSE(cos5.derivative(5u), -sin(cx), eps);
  auto sin5 = sin(x);
  BOOST_CHECK_CLOSE(sin5.derivative(0u), sin(cx), eps);
  BOOST_CHECK_CLOSE(sin5.derivative(1u), cos(cx), eps);
  BOOST_CHECK_CLOSE(sin5.derivative(2u), -sin(cx), eps);
  BOOST_CHECK_CLOSE(sin5.derivative(3u), -cos(cx), eps);
  BOOST_CHECK_CLOSE(sin5.derivative(4u), sin(cx), eps);
  BOOST_CHECK_CLOSE(sin5.derivative(5u), cos(cx), eps);
  // Test Order = 0 for codecov
  auto cos0 = cos(make_fvar<T, 0>(cx));
  BOOST_CHECK_CLOSE(cos0.derivative(0u), cos(cx), eps);
  auto sin0 = sin(make_fvar<T, 0>(cx));
  BOOST_CHECK_CLOSE(sin0.derivative(0u), sin(cx), eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(acos_test, T, bin_float_types) {
  const T eps = 300 * std::numeric_limits<T>::epsilon(); // percent
  using std::acos;
  using std::pow;
  using std::sqrt;
  constexpr std::size_t m = 5;
  const T cx = 0.5;
  auto x = make_fvar<T, m>(cx);
  auto y = acos(x);
  BOOST_CHECK_CLOSE(y.derivative(0u), acos(cx), eps);
  BOOST_CHECK_CLOSE(y.derivative(1u), -1 / sqrt(1 - cx * cx), eps);
  BOOST_CHECK_CLOSE(y.derivative(2u), -cx / pow(1 - cx * cx, 1.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(3u),
                    -(2 * cx * cx + 1) / pow(1 - cx * cx, 2.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(4u),
                    -3 * cx * (2 * cx * cx + 3) / pow(1 - cx * cx, 3.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(5u),
                    -(24 * (cx * cx + 3) * cx * cx + 9) / pow(1 - cx * cx, 4.5),
                    eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(acosh_test, T, bin_float_types) {
  const T eps = 300 * std::numeric_limits<T>::epsilon(); // percent
  using boost::math::acosh;
  constexpr std::size_t m = 5;
  const T cx = 2;
  auto x = make_fvar<T, m>(cx);
  auto y = acosh(x);
  // BOOST_CHECK_EQUAL(y.derivative(0) == acosh(cx)); // FAILS! acosh(2) is
  // overloaded for integral types
  BOOST_CHECK_CLOSE(y.derivative(0u), acosh(static_cast<T>(x)), eps);
  BOOST_CHECK_CLOSE(y.derivative(1u),
                    1 / boost::math::constants::root_three<T>(), eps);
  BOOST_CHECK_CLOSE(y.derivative(2u),
                    -2 / (3 * boost::math::constants::root_three<T>()), eps);
  BOOST_CHECK_CLOSE(y.derivative(3u),
                    1 / boost::math::constants::root_three<T>(), eps);
  BOOST_CHECK_CLOSE(y.derivative(4u),
                    -22 / (9 * boost::math::constants::root_three<T>()), eps);
  BOOST_CHECK_CLOSE(y.derivative(5u),
                    227 / (27 * boost::math::constants::root_three<T>()),
                    2 * eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(asin_test, T, bin_float_types) {
  const T eps = 300 * std::numeric_limits<T>::epsilon(); // percent
  using std::asin;
  using std::pow;
  using std::sqrt;
  constexpr std::size_t m = 5;
  const T cx = 0.5;
  auto x = make_fvar<T, m>(cx);
  auto y = asin(x);
  BOOST_CHECK_CLOSE(y.derivative(0u), asin(static_cast<T>(x)), eps);
  BOOST_CHECK_CLOSE(y.derivative(1u), 1 / sqrt(1 - cx * cx), eps);
  BOOST_CHECK_CLOSE(y.derivative(2u), cx / pow(1 - cx * cx, 1.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(3u), (2 * cx * cx + 1) / pow(1 - cx * cx, 2.5),
                    eps);
  BOOST_CHECK_CLOSE(y.derivative(4u),
                    3 * cx * (2 * cx * cx + 3) / pow(1 - cx * cx, 3.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(5u),
                    (24 * (cx * cx + 3) * cx * cx + 9) / pow(1 - cx * cx, 4.5),
                    eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(asin_infinity, T, all_float_types) {
  const T eps = 100 * std::numeric_limits<T>::epsilon(); // percent
  constexpr std::size_t m = 5;
  auto x = make_fvar<T, m>(1);
  auto y = asin(x);
  // std::cout << "asin(1) = " << y << std::endl; //
  // depth(1)(1.5707963267949,inf,inf,-nan,-nan,-nan)
  BOOST_CHECK_CLOSE(y.derivative(0u), boost::math::constants::half_pi<T>(),
                    eps); // MacOS is not exact
  BOOST_CHECK_EQUAL(y.derivative(1u), std::numeric_limits<T>::infinity());
}

BOOST_AUTO_TEST_CASE_TEMPLATE(asin_derivative, T, bin_float_types) {
  const T eps = 300 * std::numeric_limits<T>::epsilon(); // percent
  using std::pow;
  using std::sqrt;
  constexpr std::size_t m = 4;
  const T cx(0.5);
  auto x = make_fvar<T, m>(cx);
  auto y = T(1) - x * x;
  BOOST_CHECK_EQUAL(y.derivative(0u), 1 - cx * cx);
  BOOST_CHECK_EQUAL(y.derivative(1u), -2 * cx);
  BOOST_CHECK_EQUAL(y.derivative(2u), -2);
  BOOST_CHECK_EQUAL(y.derivative(3u), 0);
  BOOST_CHECK_EQUAL(y.derivative(4u), 0);
  y = sqrt(y);
  BOOST_CHECK_EQUAL(y.derivative(0u), sqrt(1 - cx * cx));
  BOOST_CHECK_CLOSE(y.derivative(1u), -cx / sqrt(1 - cx * cx), eps);
  BOOST_CHECK_CLOSE(y.derivative(2u), -1 / pow(1 - cx * cx, 1.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(3u), -3 * cx / pow(1 - cx * cx, 2.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(4u),
                    -(12 * cx * cx + 3) / pow(1 - cx * cx, 3.5), eps);
  y = y.inverse(); // asin'(x) = 1 / sqrt(1-x*x).
  BOOST_CHECK_CLOSE(y.derivative(0u), 1 / sqrt(1 - cx * cx), eps);
  BOOST_CHECK_CLOSE(y.derivative(1u), cx / pow(1 - cx * cx, 1.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(2u), (2 * cx * cx + 1) / pow(1 - cx * cx, 2.5),
                    eps);
  BOOST_CHECK_CLOSE(y.derivative(3u),
                    3 * cx * (2 * cx * cx + 3) / pow(1 - cx * cx, 3.5), eps);
  BOOST_CHECK_CLOSE(y.derivative(4u),
                    (24 * (cx * cx + 3) * cx * cx + 9) / pow(1 - cx * cx, 4.5),
                    eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(asinh_test, T, bin_float_types) {
  const T eps = 300 * std::numeric_limits<T>::epsilon(); // percent
  using boost::math::asinh;
  constexpr std::size_t m = 5;
  const T cx = 1;
  auto x = make_fvar<T, m>(cx);
  auto y = asinh(x);
  BOOST_CHECK_CLOSE(y.derivative(0u), asinh(static_cast<T>(x)), eps);
  BOOST_CHECK_CLOSE(y.derivative(1u), 1 / boost::math::constants::root_two<T>(),
                    eps);
  BOOST_CHECK_CLOSE(y.derivative(2u),
                    -1 / (2 * boost::math::constants::root_two<T>()), eps);
  BOOST_CHECK_CLOSE(y.derivative(3u),
                    1 / (4 * boost::math::constants::root_two<T>()), eps);
  BOOST_CHECK_CLOSE(y.derivative(4u),
                    3 / (8 * boost::math::constants::root_two<T>()), eps);
  BOOST_CHECK_CLOSE(y.derivative(5u),
                    -39 / (16 * boost::math::constants::root_two<T>()), eps);
}

BOOST_AUTO_TEST_CASE_TEMPLATE(atan2_function, T, all_float_types) {
  using test_constants = test_constants_t<T>;
  static constexpr auto m = test_constants::order;

  test_detail::RandomSample<T> x_sampler{-2000, 2000};
  test_detail::RandomSample<T> y_sampler{-2000, 2000};

  for (auto i : boost::irange(test_constants::n_samples)) {
    std::ignore = i;
    auto x = x_sampler.next();
    auto y = y_sampler.next();

    auto autodiff_v = atan2(make_fvar<T, m>(x), make_fvar<T, m>(y));
    auto anchor_v = atan2(x, y);
    BOOST_CHECK_CLOSE(autodiff_v, anchor_v,
                      5000 * test_constants::pct_epsilon());
  }
}

BOOST_AUTO_TEST_SUITE_END()