diff --git a/include/boost/math/differentiation/autodiff.hpp b/include/boost/math/differentiation/autodiff.hpp index 586c35a186..a96bd4604b 100644 --- a/include/boost/math/differentiation/autodiff.hpp +++ b/include/boost/math/differentiation/autodiff.hpp @@ -383,6 +383,21 @@ class fvar { template fvar apply_derivatives_nonhorner(size_t const order, Func const& f) const; + // Taylor coefficients of y(x), x = *this, by recurrence from the differential equation y satisfies. + // These take O(Order^2) multiplications; apply_derivatives takes O(Order^3). + + // y' = y x' and y[0] = y0: exp. + fvar integrate(RealType const& y0) const; + + // y' = g x' and y[0] = y0. + fvar integrate(RealType const& y0, fvar const& g) const; + + // x y' = p x' y and y[0] = y0: pow(x, p). Requires x[0] != 0. + fvar integrate_pow(RealType const& y0, root_type const& p) const; + + // s' = c x' and c' = sign * s x': {sin(x), cos(x)} for sign = -1, {sinh(x), cosh(x)} for sign = 1. + std::pair integrate_sin_cos(int sign) const; + private: RealType epsilon_inner_product(size_t z0, size_t isum0, @@ -399,6 +414,8 @@ class fvar { fvar inverse_apply() const; + RealType ode_coefficient(size_t k, fvar const& g) const; + fvar& multiply_assign_by_root_type(bool is_root, root_type const&); template @@ -1316,6 +1333,89 @@ fvar fvar::epsilon_multiply(size_t z0, } #endif +template +bool is_zero(RealType const& x) { + return x == 0; +} + +template +bool is_zero(fvar const& x) { + for (size_t i = 0; i <= Order; ++i) + if (!is_zero(x[i])) + return false; + return true; +} + +// {sin(x), cos(x)} for sign = -1, {sinh(x), cosh(x)} for sign = 1. +template +std::pair sin_cos(RealType const& x, int sign) { + BOOST_MATH_STD_USING + return sign < 0 ? std::make_pair(sin(x), cos(x)) : std::make_pair(sinh(x), cosh(x)); +} + +template +std::pair, fvar> sin_cos(fvar const& x, int sign) { + return x.integrate_sin_cos(sign); +} + +// Coefficient k of the y with y' = g x': k y_k = sum_{j=1}^{k} j x_j g_{k-j}. Reads g[0..k-1] only. +// A zero x_j is skipped, as g_{k-j} may be infinite. +template +RealType fvar::ode_coefficient(size_t k, fvar const& g) const { + RealType sum(0); + for (size_t j = 1; j <= k; ++j) + if (!is_zero(v[j])) + sum += static_cast(j) * v[j] * g.v[k - j]; + return sum / static_cast(k); +} + +template +fvar fvar::integrate(RealType const& y0) const { + fvar y; + y.v.front() = y0; + for (size_t k = 1; k <= Order; ++k) + y.v[k] = ode_coefficient(k, y); + return y; +} + +template +fvar fvar::integrate(RealType const& y0, + fvar const& g) const { + fvar y; + y.v.front() = y0; + for (size_t k = 1; k <= Order; ++k) + y.v[k] = ode_coefficient(k, g); + return y; +} + +// k x_0 y_k = sum_{j=1}^{k} (p j - (k - j)) x_j y_{k-j} +template +fvar fvar::integrate_pow(RealType const& y0, root_type const& p) const { + fvar y; + y.v.front() = y0; + for (size_t k = 1; k <= Order; ++k) { + RealType sum(0); + for (size_t j = 1; j <= k; ++j) + sum += (p * static_cast(j) - static_cast(k - j)) * v[j] * y.v[k - j]; + y.v[k] = (sum /= static_cast(k)) / v.front(); + } + return y; +} + +template +std::pair, fvar> fvar::integrate_sin_cos( + int sign) const { + std::pair const y0 = sin_cos(v.front(), sign); + std::pair, fvar> y; + y.first.v.front() = y0.first; + y.second.v.front() = y0.second; + for (size_t k = 1; k <= Order; ++k) { + y.first.v[k] = ode_coefficient(k, y.second); + y.second.v[k] = static_cast(sign) * ode_coefficient(k, y.first); + } + return y; +} + template fvar fvar::inverse() const { return static_cast(*this) == 0 ? inverse_apply() : 1 / *this; @@ -1416,10 +1516,7 @@ fvar floor(fvar const& cr) { template fvar exp(fvar const& cr) { using std::exp; - constexpr size_t order = fvar::order_sum; - using root_type = typename fvar::root_type; - root_type const d0 = exp(static_cast(cr)); - return cr.apply_derivatives(order, [&d0](size_t) { return d0; }); + return cr.integrate(exp(cr[0])); } template @@ -1429,6 +1526,10 @@ fvar pow(fvar const& x, using root_type = typename fvar::root_type; constexpr size_t order = fvar::order_sum; root_type const x0 = static_cast(x); + // Not for the polynomials x^0, x^1, ..., whose higher derivatives the code below makes exactly zero. + if (std::numeric_limits::epsilon() <= fabs(x0) && fabs(x0) <= (std::numeric_limits::max)() && + !(0 <= y && y < order && floor(y) == y)) + return x.integrate_pow(pow(x[0], y), y); root_type derivatives[order + 1]{pow(x0, y)}; if (fabs(x0) < std::numeric_limits::epsilon()) { root_type coef = 1; @@ -1448,15 +1549,7 @@ template fvar pow(typename fvar::root_type const& x, fvar const& y) { BOOST_MATH_STD_USING - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const y0 = static_cast(y); - root_type derivatives[order + 1]; - *derivatives = pow(x, y0); - root_type const logx = log(x); - for (size_t i = 0; i < order; ++i) - derivatives[i + 1] = derivatives[i] * logx; - return y.apply_derivatives(order, [&derivatives](size_t i) { return derivatives[i]; }); + return (y * log(x)).integrate(pow(x, y[0])); // x^y = exp(y log(x)) } template @@ -1503,6 +1596,8 @@ fvar sqrt(fvar const& cr) { using std::sqrt; using root_type = typename fvar::root_type; constexpr size_t order = fvar::order_sum; + if (cr >= std::numeric_limits::epsilon() && cr <= (std::numeric_limits::max)()) + return cr.integrate_pow(sqrt(cr[0]), root_type(0.5)); root_type derivatives[order + 1]; root_type const x = static_cast(cr); *derivatives = sqrt(x); @@ -1535,6 +1630,8 @@ fvar log(fvar const& cr) { using std::log; using root_type = typename fvar::root_type; constexpr size_t order = fvar::order_sum; + if (static_cast(cr) != 0) + return cr.integrate(log(cr[0]), 1 / cr); root_type const d0 = log(static_cast(cr)); BOOST_MATH_IF_CONSTEXPR (order == 0) return fvar(d0); @@ -1562,77 +1659,31 @@ fvar ldexp(fvar const& cr, int exp) { template fvar cos(fvar const& cr) { - BOOST_MATH_STD_USING - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = cos(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - root_type const d1 = -sin(static_cast(cr)); - root_type const derivatives[4]{d0, d1, -d0, -d1}; - return cr.apply_derivatives(order, [&derivatives](size_t i) { return derivatives[i & 3]; }); - } + return cr.integrate_sin_cos(-1).second; } template fvar sin(fvar const& cr) { - BOOST_MATH_STD_USING - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = sin(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - root_type const d1 = cos(static_cast(cr)); - root_type const derivatives[4]{d0, d1, -d0, -d1}; - return cr.apply_derivatives(order, [&derivatives](size_t i) { return derivatives[i & 3]; }); - } + return cr.integrate_sin_cos(-1).first; } template fvar asin(fvar const& cr) { using std::asin; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = asin(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); - auto const d1 = sqrt((x *= x).negate() += 1).inverse(); // asin'(x) = 1 / sqrt(1-x*x). - return cr.apply_coefficients_nonhorner(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + return cr.integrate(asin(cr[0]), sqrt((cr * cr).negate() += 1).inverse()); // asin'(x) = 1 / sqrt(1-x*x) } template fvar tan(fvar const& cr) { using std::tan; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = tan(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto c = cos(make_fvar(static_cast(cr))); - auto const d1 = (c *= c).inverse(); // tan'(x) = 1 / cos(x)^2 - return cr.apply_coefficients_nonhorner(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + auto c = cos(cr); + return cr.integrate(tan(cr[0]), (c *= c).inverse()); // tan'(x) = 1 / cos(x)^2 } template fvar atan(fvar const& cr) { using std::atan; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = atan(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); - auto const d1 = ((x *= x) += 1).inverse(); // atan'(x) = 1 / (x*x+1). - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + return cr.integrate(atan(cr[0]), ((cr * cr) += 1).inverse()); // atan'(x) = 1 / (x*x+1) } template @@ -1775,75 +1826,30 @@ std::ostream& operator<<(std::ostream& out, fvar const& cr) { template fvar acos(fvar const& cr) { using std::acos; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = acos(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); - auto const d1 = sqrt((x *= x).negate() += 1).inverse().negate(); // acos'(x) = -1 / sqrt(1-x*x). - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + return cr.integrate(acos(cr[0]), sqrt((cr * cr).negate() += 1).inverse().negate()); // acos'(x) = -1 / sqrt(1-x*x) } template fvar acosh(fvar const& cr) { using BOOST_MATH_NAMESPACE::acosh; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = acosh(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); - auto const d1 = sqrt((x *= x) -= 1).inverse(); // acosh'(x) = 1 / sqrt(x*x-1). - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + return cr.integrate(acosh(cr[0]), sqrt((cr * cr) -= 1).inverse()); // acosh'(x) = 1 / sqrt(x*x-1) } template fvar asinh(fvar const& cr) { using BOOST_MATH_NAMESPACE::asinh; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = asinh(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); - auto const d1 = sqrt((x *= x) += 1).inverse(); // asinh'(x) = 1 / sqrt(x*x+1). - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + return cr.integrate(asinh(cr[0]), sqrt((cr * cr) += 1).inverse()); // asinh'(x) = 1 / sqrt(x*x+1) } template fvar atanh(fvar const& cr) { using BOOST_MATH_NAMESPACE::atanh; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = atanh(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); - auto const d1 = ((x *= x).negate() += 1).inverse(); // atanh'(x) = 1 / (1-x*x) - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + return cr.integrate(atanh(cr[0]), ((cr * cr).negate() += 1).inverse()); // atanh'(x) = 1 / (1-x*x) } template fvar cosh(fvar const& cr) { - BOOST_MATH_STD_USING - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = cosh(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - root_type const derivatives[2]{d0, sinh(static_cast(cr))}; - return cr.apply_derivatives(order, [&derivatives](size_t i) { return derivatives[i & 1]; }); - } + return cr.integrate_sin_cos(1).second; } template @@ -1866,31 +1872,15 @@ fvar digamma(fvar const& cr) { template fvar erf(fvar const& cr) { using BOOST_MATH_NAMESPACE::erf; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = erf(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); // d1 = 2/sqrt(pi)*exp(-x*x) - auto const d1 = 2 * constants::one_div_root_pi() * exp((x *= x).negate()); - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + using root_type = typename fvar::root_type; // erf'(x) = 2/sqrt(pi)*exp(-x*x) + return cr.integrate(erf(cr[0]), 2 * constants::one_div_root_pi() * exp((cr * cr).negate())); } template fvar erfc(fvar const& cr) { using BOOST_MATH_NAMESPACE::erfc; - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = erfc(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (order == 0) - return fvar(d0); - else { - auto x = make_fvar(static_cast(cr)); // erfc'(x) = -erf'(x) - auto const d1 = -2 * constants::one_div_root_pi() * exp((x *= x).negate()); - return cr.apply_coefficients(order, [&d0, &d1](size_t i) { return i ? d1[i - 1] / i : d0; }); - } + using root_type = typename fvar::root_type; // erfc'(x) = -erf'(x) + return cr.integrate(erfc(cr[0]), -2 * constants::one_div_root_pi() * exp((cr * cr).negate())); } template @@ -1966,16 +1956,7 @@ fvar sinc(fvar const& cr) { template fvar sinh(fvar const& cr) { - BOOST_MATH_STD_USING - using root_type = typename fvar::root_type; - constexpr size_t order = fvar::order_sum; - root_type const d0 = sinh(static_cast(cr)); - BOOST_MATH_IF_CONSTEXPR (fvar::order_sum == 0) - return fvar(d0); - else { - root_type const derivatives[2]{d0, cosh(static_cast(cr))}; - return cr.apply_derivatives(order, [&derivatives](size_t i) { return derivatives[i & 1]; }); - } + return cr.integrate_sin_cos(1).first; } template diff --git a/reporting/performance/autodiff_performance.cpp b/reporting/performance/autodiff_performance.cpp new file mode 100644 index 0000000000..d73c609c64 --- /dev/null +++ b/reporting/performance/autodiff_performance.cpp @@ -0,0 +1,208 @@ +// (C) Copyright Sayan Samanta 2026. +// 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) +// +// Build: c++ -std=c++17 -O2 -I../../include autodiff_performance.cpp -lbenchmark -o autodiff_performance + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using boost::math::constants::one_div_root_two; +using boost::math::differentiation::make_ftuple; +using boost::math::differentiation::make_fvar; +using boost::math::generate_random_uniform_vector; +using boost::math::tools::evaluate_polynomial; + +template +Real transcendental(const Real& x) +{ + using std::exp; + using std::log; + using std::sin; + using std::sqrt; + return exp(sin(x)) * log(1.0 + x * x) / sqrt(x); +} + +template +auto two_variables(const X& x, const Y& y) +{ + return exp(sin(x) * y) * log(1.0 + x * x + y * y) / sqrt(x * y); +} + +template +auto three_variables(const X& x, const Y& y, const Z& z) +{ + return exp(sin(x) * y) * log(1.0 + x * x + z * z) / sqrt(y * z) + cos(x * z) * erfc(y); +} + +// From example/autodiff_black_scholes.cpp. +template +auto black_scholes(const Price& S, const Sigma& sigma, const Tau& tau, const Rate& r) +{ + using std::exp; + using std::sqrt; + constexpr double K = 100.0; + const auto sst = sigma * sqrt(tau); + const auto d1 = (log(S / K) + (r + sigma * sigma / 2) * tau) / sst; + const auto d2 = d1 - sst; + auto Phi = [](const auto& z) { return 0.5 * erfc(-one_div_root_two() * z); }; + return S * Phi(d1) - exp(-r * tau) * K * Phi(d2); +} + +// Excess Gibbs energy of a mixed-solvent electrolyte (MSE model) as a function of the +// pressure P in MPa: a Pitzer-Debye-Huckel long-range term, through the solvent density +// and dielectric constant, and a middle-range ionic term. dG/dP is the excess volume. +template +Real mse_gibbs_energy(const Real& P, const std::vector& x, const std::vector& z, + const std::vector& b0, const std::vector& b1) +{ + using std::exp; + using std::log; + using std::pow; + using std::sqrt; + const std::size_t n = x.size(); + double I = 0; + for (std::size_t i = 0; i < n; ++i) + { + I += 0.5 * z[i] * z[i] * x[i]; + } + constexpr double rho = 14.9; + const Real density = exp(4.5e-4 * (P - 0.1)); + const Real dielectric = 1.0 + 0.0216 * log((300.0 + P) / 300.1); + const Real Ax = 2.917 * sqrt(density) * pow(dielectric, -1.5); + Real g = -4.0 * I / rho * std::log(1.0 + rho * std::sqrt(I)) * Ax; + const double e = std::exp(-std::sqrt(I + 0.01)); + for (std::size_t i = 0; i < n; ++i) + { + for (std::size_t j = 0; j < n; ++j) + { + g += x[i] * x[j] * e * (b0[i * n + j] + b1[i * n + j] * P); + } + } + return g; +} + +template +void run(benchmark::State& state, double x, F f) +{ + const auto v = make_fvar(x); + for (auto _ : state) + { + benchmark::DoNotOptimize(f(v)); + } +} + +// Runs f on a variable of the order given by state.range(0); the order is the N of the complexity fit. +template +void run_at_order(benchmark::State& state, double x, F f, std::index_sequence) +{ + const auto order = static_cast(state.range(0)); + ((order == Orders + 1 ? run(state, x, f) : void()), ...); + state.SetComplexityN(state.range(0)); +} + +template +void run_at_order(benchmark::State& state, double x, F f) +{ + run_at_order(state, x, f, std::make_index_sequence<32>()); +} + +// Calls f(std::integral_constant()), N = state.range(0): the order in each variable. +template +void run_at_order(benchmark::State& state, F f, std::index_sequence) +{ + const auto order = static_cast(state.range(0)); + ((order == Orders + 1 ? f(std::integral_constant()) : void()), ...); +} + +void Horner(benchmark::State& state) +{ + const auto c = generate_random_uniform_vector(64, 12345, -1, 1); + run_at_order(state, 0.5, [&](const auto& x) { return evaluate_polynomial(c.data(), x, c.size()); }); +} + +void Transcendental(benchmark::State& state) +{ + run_at_order(state, 2.5, [](const auto& x) { return transcendental(x); }); +} + +void BlackScholes(benchmark::State& state) +{ + run_at_order(state, 105.0, [](const auto& S) { return black_scholes(S, 0.25, 0.5, 0.01); }); +} + +void TwoVariables(benchmark::State& state) +{ + auto f = [&](auto order) { + constexpr std::size_t N = decltype(order)::value; + const auto v = make_ftuple(1.3, 0.7); + for (auto _ : state) + { + benchmark::DoNotOptimize(two_variables(std::get<0>(v), std::get<1>(v))); + } + }; + run_at_order(state, f, std::make_index_sequence<12>()); +} + +void ThreeVariables(benchmark::State& state) +{ + auto f = [&](auto order) { + constexpr std::size_t N = decltype(order)::value; + const auto v = make_ftuple(1.3, 0.7, 2.1); + for (auto _ : state) + { + benchmark::DoNotOptimize(three_variables(std::get<0>(v), std::get<1>(v), std::get<2>(v))); + } + }; + run_at_order(state, f, std::make_index_sequence<6>()); +} + +// The price as a function of (S, sigma, tau, r). +void BlackScholesFourVariables(benchmark::State& state) +{ + auto f = [&](auto order) { + constexpr std::size_t N = decltype(order)::value; + const auto v = make_ftuple(105.0, 0.25, 0.5, 0.01); + for (auto _ : state) + { + benchmark::DoNotOptimize( + black_scholes(std::get<0>(v), std::get<1>(v), std::get<2>(v), std::get<3>(v))); + } + }; + run_at_order(state, f, std::make_index_sequence<4>()); +} + +// 16 species: a solvent, alternating cations and anions, and a neutral solute. +void MseGibbsEnergy(benchmark::State& state) +{ + constexpr std::size_t n = 16; + std::vector x(n, 0.2 / (n - 1)); + std::vector z(n, 0.0); + x[0] = 0.8; + for (std::size_t i = 1; i + 1 < n; ++i) + { + z[i] = (i % 2) ? 1 : -1; + } + const auto b0 = generate_random_uniform_vector(n * n, 12345, -0.5, 0.5); + const auto b1 = generate_random_uniform_vector(n * n, 12345, -5e-4, 5e-4); + run_at_order(state, 0.1, [&](const auto& P) { return mse_gibbs_energy(P, x, z, b0, b1); }); +} + +BENCHMARK(Horner)->DenseRange(1, 32)->Complexity(); +BENCHMARK(Transcendental)->DenseRange(1, 32)->Complexity(); +BENCHMARK(BlackScholes)->DenseRange(1, 32)->Complexity(); +BENCHMARK(MseGibbsEnergy)->DenseRange(1, 32)->Complexity(); +BENCHMARK(TwoVariables)->DenseRange(1, 12); +BENCHMARK(ThreeVariables)->DenseRange(1, 6); +BENCHMARK(BlackScholesFourVariables)->DenseRange(1, 4); + +BENCHMARK_MAIN(); diff --git a/test/test_autodiff_2.cpp b/test/test_autodiff_2.cpp index d9b3327712..c71648d5f8 100644 --- a/test/test_autodiff_2.cpp +++ b/test/test_autodiff_2.cpp @@ -333,7 +333,7 @@ void ylogx() { CHECK_RELATIVE_ERROR(z1.derivative(2u, 4u), pow(cx, cy - 2) * pow(log(cx), T(2)) * (4 * (2 * cy - 1) * log(cx) + (4 - 1) * 4 + - (cy - 1) * cy * pow(log(cx), T(2))), (eps) / 100); + (cy - 1) * cy * pow(log(cx), T(2))), (eps) / 25); } template