| 1 |
// Copyright (c) 2006 Xiaogang Zhang |
| 2 |
// Copyright (c) 2006 John Maddock |
| 3 |
// Copyright (c) 2024 Matt Borland |
| 4 |
// Use, modification and distribution are subject to the |
| 5 |
// Boost Software License, Version 1.0. (See accompanying file |
| 6 |
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| 7 |
// |
| 8 |
// History: |
| 9 |
// XZ wrote the original of this file as part of the Google |
| 10 |
// Summer of Code 2006. JM modified it to fit into the |
| 11 |
// Boost.Math conceptual framework better, and to ensure |
| 12 |
// that the code continues to work no matter how many digits |
| 13 |
// type T has. |
| 14 |
|
| 15 |
#ifndef BOOST_MATH_ELLINT_2_HPP |
| 16 |
#define BOOST_MATH_ELLINT_2_HPP |
| 17 |
|
| 18 |
#ifdef _MSC_VER |
| 19 |
#pragma once |
| 20 |
#endif |
| 21 |
|
| 22 |
#include <boost/math/tools/config.hpp> |
| 23 |
#include <boost/math/tools/numeric_limits.hpp> |
| 24 |
#include <boost/math/tools/type_traits.hpp> |
| 25 |
#include <boost/math/special_functions/math_fwd.hpp> |
| 26 |
#include <boost/math/special_functions/ellint_rf.hpp> |
| 27 |
#include <boost/math/special_functions/ellint_rd.hpp> |
| 28 |
#include <boost/math/special_functions/ellint_rg.hpp> |
| 29 |
#include <boost/math/constants/constants.hpp> |
| 30 |
#include <boost/math/policies/error_handling.hpp> |
| 31 |
#include <boost/math/tools/workaround.hpp> |
| 32 |
#include <boost/math/special_functions/round.hpp> |
| 33 |
|
| 34 |
// Elliptic integrals (complete and incomplete) of the second kind |
| 35 |
// Carlson, Numerische Mathematik, vol 33, 1 (1979) |
| 36 |
|
| 37 |
namespace boost { namespace math { |
| 38 |
|
| 39 |
template <class T1, class T2, class Policy> |
| 40 |
BOOST_MATH_GPU_ENABLED typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol); |
| 41 |
|
| 42 |
namespace detail{ |
| 43 |
|
| 44 |
template <typename T, typename Policy> |
| 45 |
BOOST_MATH_GPU_ENABLED BOOST_MATH_FORCEINLINE T ellint_e_imp(T k, const Policy& pol, const boost::math::integral_constant<int, 0>&); |
| 46 |
template <typename T, typename Policy> |
| 47 |
BOOST_MATH_GPU_ENABLED BOOST_MATH_FORCEINLINE T ellint_e_imp(T k, const Policy& pol, const boost::math::integral_constant<int, 1>&); |
| 48 |
template <typename T, typename Policy> |
| 49 |
BOOST_MATH_GPU_ENABLED BOOST_MATH_FORCEINLINE T ellint_e_imp(T k, const Policy& pol, const boost::math::integral_constant<int, 2>&); |
| 50 |
|
| 51 |
// Elliptic integral (Legendre form) of the second kind |
| 52 |
template <typename T, typename Policy> |
| 53 |
BOOST_MATH_GPU_ENABLED T ellint_e_imp(T phi, T k, const Policy& pol) |
| 54 |
{ |
| 55 |
BOOST_MATH_STD_USING |
| 56 |
using namespace boost::math::tools; |
| 57 |
using namespace boost::math::constants; |
| 58 |
|
| 59 |
bool invert = false; |
| 60 |
if (phi == 0) |
| 61 |
return 0; |
| 62 |
|
| 63 |
if(phi < 0) |
| 64 |
{ |
| 65 |
phi = fabs(phi); |
| 66 |
invert = true; |
| 67 |
} |
| 68 |
|
| 69 |
T result; |
| 70 |
|
| 71 |
if(phi >= tools::max_value<T>()) |
| 72 |
{ |
| 73 |
// Need to handle infinity as a special case: |
| 74 |
result = policies::raise_overflow_error<T>("boost::math::ellint_e<%1%>(%1%,%1%)", nullptr, pol); |
| 75 |
} |
| 76 |
else if(phi > 1 / tools::epsilon<T>()) |
| 77 |
{ |
| 78 |
typedef boost::math::integral_constant<int, |
| 79 |
boost::math::is_floating_point<T>::value&& boost::math::numeric_limits<T>::digits && (boost::math::numeric_limits<T>::digits <= 54) ? 0 : |
| 80 |
boost::math::is_floating_point<T>::value && boost::math::numeric_limits<T>::digits && (boost::math::numeric_limits<T>::digits <= 64) ? 1 : 2 |
| 81 |
> precision_tag_type; |
| 82 |
// Phi is so large that phi%pi is necessarily zero (or garbage), |
| 83 |
// just return the second part of the duplication formula: |
| 84 |
result = 2 * phi * ellint_e_imp(k, pol, precision_tag_type()) / constants::pi<T>(); |
| 85 |
} |
| 86 |
else if(k == 0) |
| 87 |
{ |
| 88 |
return invert ? T(-phi) : phi; |
| 89 |
} |
| 90 |
else if(fabs(k) == 1) |
| 91 |
{ |
| 92 |
// |
| 93 |
// For k = 1 ellipse actually turns to a line and every pi/2 in phi is exactly 1 in arc length |
| 94 |
// Periodicity though is in pi, curve follows sin(pi) for 0 <= phi <= pi/2 and then |
| 95 |
// 2 - sin(pi- phi) = 2 + sin(phi - pi) for pi/2 <= phi <= pi, so general form is: |
| 96 |
// |
| 97 |
// 2n + sin(phi - n * pi) ; |phi - n * pi| <= pi / 2 |
| 98 |
// |
| 99 |
T m = boost::math::round(phi / boost::math::constants::pi<T>()); |
| 100 |
T remains = phi - m * boost::math::constants::pi<T>(); |
| 101 |
T value = 2 * m + sin(remains); |
| 102 |
|
| 103 |
// negative arc length for negative phi |
| 104 |
return invert ? -value : value; |
| 105 |
} |
| 106 |
else |
| 107 |
{ |
| 108 |
// Carlson's algorithm works only for |phi| <= pi/2, |
| 109 |
// use the integrand's periodicity to normalize phi |
| 110 |
// |
| 111 |
// Xiaogang's original code used a cast to long long here |
| 112 |
// but that fails if T has more digits than a long long, |
| 113 |
// so rewritten to use fmod instead: |
| 114 |
// |
| 115 |
T rphi = boost::math::tools::fmod_workaround(phi, T(constants::half_pi<T>())); |
| 116 |
T m = boost::math::round((phi - rphi) / constants::half_pi<T>()); |
| 117 |
int s = 1; |
| 118 |
if(boost::math::tools::fmod_workaround(m, T(2)) > T(0.5)) |
| 119 |
{ |
| 120 |
m += 1; |
| 121 |
s = -1; |
| 122 |
rphi = constants::half_pi<T>() - rphi; |
| 123 |
} |
| 124 |
T k2 = k * k; |
| 125 |
if(boost::math::pow<3>(rphi) * k2 / 6 < tools::epsilon<T>() * fabs(rphi)) |
| 126 |
{ |
| 127 |
// See http://functions.wolfram.com/EllipticIntegrals/EllipticE2/06/01/03/0001/ |
| 128 |
result = s * rphi; |
| 129 |
} |
| 130 |
else |
| 131 |
{ |
| 132 |
// http://dlmf.nist.gov/19.25#E10 |
| 133 |
T sinp = sin(rphi); |
| 134 |
if (k2 * sinp * sinp >= 1) |
| 135 |
{ |
| 136 |
return policies::raise_domain_error<T>("boost::math::ellint_2<%1%>(%1%, %1%)", "The parameter k is out of range, got k = %1%", k, pol); |
| 137 |
} |
| 138 |
T cosp = cos(rphi); |
| 139 |
T c = 1 / (sinp * sinp); |
| 140 |
T cm1 = cosp * cosp / (sinp * sinp); // c - 1 |
| 141 |
result = s * ((1 - k2) * ellint_rf_imp(cm1, T(c - k2), c, pol) + k2 * (1 - k2) * ellint_rd(cm1, c, T(c - k2), pol) / 3 + k2 * sqrt(cm1 / (c * (c - k2)))); |
| 142 |
} |
| 143 |
if (m != 0) |
| 144 |
{ |
| 145 |
typedef boost::math::integral_constant<int, |
| 146 |
boost::math::is_floating_point<T>::value&& boost::math::numeric_limits<T>::digits && (boost::math::numeric_limits<T>::digits <= 54) ? 0 : |
| 147 |
boost::math::is_floating_point<T>::value && boost::math::numeric_limits<T>::digits && (boost::math::numeric_limits<T>::digits <= 64) ? 1 : 2 |
| 148 |
> precision_tag_type; |
| 149 |
result += m * ellint_e_imp(k, pol, precision_tag_type()); |
| 150 |
} |
| 151 |
} |
| 152 |
return invert ? T(-result) : result; |
| 153 |
} |
| 154 |
|
| 155 |
// Complete elliptic integral (Legendre form) of the second kind |
| 156 |
template <typename T, typename Policy> |
| 157 |
BOOST_MATH_GPU_ENABLED T ellint_e_imp(T k, const Policy& pol, boost::math::integral_constant<int, 2> const&) |
| 158 |
{ |
| 159 |
BOOST_MATH_STD_USING |
| 160 |
using namespace boost::math::tools; |
| 161 |
|
| 162 |
if (abs(k) > 1) |
| 163 |
{ |
| 164 |
return policies::raise_domain_error<T>("boost::math::ellint_e<%1%>(%1%)", "Got k = %1%, function requires |k| <= 1", k, pol); |
| 165 |
} |
| 166 |
if (abs(k) == 1) |
| 167 |
{ |
| 168 |
return static_cast<T>(1); |
| 169 |
} |
| 170 |
|
| 171 |
T x = 0; |
| 172 |
T t = k * k; |
| 173 |
T y = 1 - t; |
| 174 |
T z = 1; |
| 175 |
T value = 2 * ellint_rg_imp(x, y, z, pol); |
| 176 |
|
| 177 |
return value; |
| 178 |
} |
| 179 |
// |
| 180 |
// Special versions for double and 80-bit long double precision, |
| 181 |
// double precision versions use the coefficients from: |
| 182 |
// "Fast computation of complete elliptic integrals and Jacobian elliptic functions", |
| 183 |
// Celestial Mechanics and Dynamical Astronomy, April 2012. |
| 184 |
// |
| 185 |
// Higher precision coefficients for 80-bit long doubles can be calculated |
| 186 |
// using for example: |
| 187 |
// Table[N[SeriesCoefficient[ EllipticE [ m ], { m, 875/1000, i} ], 20], {i, 0, 24}] |
| 188 |
// and checking the value of the first neglected term with: |
| 189 |
// N[SeriesCoefficient[ EllipticE [ m ], { m, 875/1000, 24} ], 20] * (2.5/100)^24 |
| 190 |
// |
| 191 |
// For m > 0.9 we don't use the method of the paper above, but simply call our |
| 192 |
// existing routines. |
| 193 |
// |
| 194 |
template <typename T, typename Policy> |
| 195 |
BOOST_MATH_GPU_ENABLED BOOST_MATH_FORCEINLINE T ellint_e_imp(T k, const Policy& pol, boost::math::integral_constant<int, 0> const&) |
| 196 |
{ |
| 197 |
BOOST_MATH_STD_USING |
| 198 |
using namespace boost::math::tools; |
| 199 |
|
| 200 |
T m = k * k; |
| 201 |
switch (static_cast<int>(20 * m)) |
| 202 |
{ |
| 203 |
case 0: |
| 204 |
case 1: |
| 205 |
//if (m < 0.1) |
| 206 |
{ |
| 207 |
constexpr T coef[] = |
| 208 |
{ |
| 209 |
static_cast<T>(1.550973351780472328), |
| 210 |
-static_cast<T>(0.400301020103198524), |
| 211 |
-static_cast<T>(0.078498619442941939), |
| 212 |
-static_cast<T>(0.034318853117591992), |
| 213 |
-static_cast<T>(0.019718043317365499), |
| 214 |
-static_cast<T>(0.013059507731993309), |
| 215 |
-static_cast<T>(0.009442372874146547), |
| 216 |
-static_cast<T>(0.007246728512402157), |
| 217 |
-static_cast<T>(0.005807424012956090), |
| 218 |
-static_cast<T>(0.004809187786009338), |
| 219 |
-static_cast<T>(0.004086399233255150) |
| 220 |
}; |
| 221 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.05)); |
| 222 |
} |
| 223 |
case 2: |
| 224 |
case 3: |
| 225 |
//else if (m < 0.2) |
| 226 |
{ |
| 227 |
constexpr T coef[] = |
| 228 |
{ |
| 229 |
static_cast<T>(1.510121832092819728), |
| 230 |
-static_cast<T>(0.417116333905867549), |
| 231 |
-static_cast<T>(0.090123820404774569), |
| 232 |
-static_cast<T>(0.043729944019084312), |
| 233 |
-static_cast<T>(0.027965493064761785), |
| 234 |
-static_cast<T>(0.020644781177568105), |
| 235 |
-static_cast<T>(0.016650786739707238), |
| 236 |
-static_cast<T>(0.014261960828842520), |
| 237 |
-static_cast<T>(0.012759847429264803), |
| 238 |
-static_cast<T>(0.011799303775587354), |
| 239 |
-static_cast<T>(0.011197445703074968) |
| 240 |
}; |
| 241 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.15)); |
| 242 |
} |
| 243 |
case 4: |
| 244 |
case 5: |
| 245 |
//else if (m < 0.3) |
| 246 |
{ |
| 247 |
constexpr T coef[] = |
| 248 |
{ |
| 249 |
static_cast<T>(1.467462209339427155), |
| 250 |
-static_cast<T>(0.436576290946337775), |
| 251 |
-static_cast<T>(0.105155557666942554), |
| 252 |
-static_cast<T>(0.057371843593241730), |
| 253 |
-static_cast<T>(0.041391627727340220), |
| 254 |
-static_cast<T>(0.034527728505280841), |
| 255 |
-static_cast<T>(0.031495443512532783), |
| 256 |
-static_cast<T>(0.030527000890325277), |
| 257 |
-static_cast<T>(0.030916984019238900), |
| 258 |
-static_cast<T>(0.032371395314758122), |
| 259 |
-static_cast<T>(0.034789960386404158) |
| 260 |
}; |
| 261 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.25)); |
| 262 |
} |
| 263 |
case 6: |
| 264 |
case 7: |
| 265 |
//else if (m < 0.4) |
| 266 |
{ |
| 267 |
constexpr T coef[] = |
| 268 |
{ |
| 269 |
static_cast<T>(1.422691133490879171), |
| 270 |
-static_cast<T>(0.459513519621048674), |
| 271 |
-static_cast<T>(0.125250539822061878), |
| 272 |
-static_cast<T>(0.078138545094409477), |
| 273 |
-static_cast<T>(0.064714278472050002), |
| 274 |
-static_cast<T>(0.062084339131730311), |
| 275 |
-static_cast<T>(0.065197032815572477), |
| 276 |
-static_cast<T>(0.072793895362578779), |
| 277 |
-static_cast<T>(0.084959075171781003), |
| 278 |
-static_cast<T>(0.102539850131045997), |
| 279 |
-static_cast<T>(0.127053585157696036), |
| 280 |
-static_cast<T>(0.160791120691274606) |
| 281 |
}; |
| 282 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.35)); |
| 283 |
} |
| 284 |
case 8: |
| 285 |
case 9: |
| 286 |
//else if (m < 0.5) |
| 287 |
{ |
| 288 |
constexpr T coef[] = |
| 289 |
{ |
| 290 |
static_cast<T>(1.375401971871116291), |
| 291 |
-static_cast<T>(0.487202183273184837), |
| 292 |
-static_cast<T>(0.153311701348540228), |
| 293 |
-static_cast<T>(0.111849444917027833), |
| 294 |
-static_cast<T>(0.108840952523135768), |
| 295 |
-static_cast<T>(0.122954223120269076), |
| 296 |
-static_cast<T>(0.152217163962035047), |
| 297 |
-static_cast<T>(0.200495323642697339), |
| 298 |
-static_cast<T>(0.276174333067751758), |
| 299 |
-static_cast<T>(0.393513114304375851), |
| 300 |
-static_cast<T>(0.575754406027879147), |
| 301 |
-static_cast<T>(0.860523235727239756), |
| 302 |
-static_cast<T>(1.308833205758540162) |
| 303 |
}; |
| 304 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.45)); |
| 305 |
} |
| 306 |
case 10: |
| 307 |
case 11: |
| 308 |
//else if (m < 0.6) |
| 309 |
{ |
| 310 |
constexpr T coef[] = |
| 311 |
{ |
| 312 |
static_cast<T>(1.325024497958230082), |
| 313 |
-static_cast<T>(0.521727647557566767), |
| 314 |
-static_cast<T>(0.194906430482126213), |
| 315 |
-static_cast<T>(0.171623726822011264), |
| 316 |
-static_cast<T>(0.202754652926419141), |
| 317 |
-static_cast<T>(0.278798953118534762), |
| 318 |
-static_cast<T>(0.420698457281005762), |
| 319 |
-static_cast<T>(0.675948400853106021), |
| 320 |
-static_cast<T>(1.136343121839229244), |
| 321 |
-static_cast<T>(1.976721143954398261), |
| 322 |
-static_cast<T>(3.531696773095722506), |
| 323 |
-static_cast<T>(6.446753640156048150), |
| 324 |
-static_cast<T>(11.97703130208884026) |
| 325 |
}; |
| 326 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.55)); |
| 327 |
} |
| 328 |
case 12: |
| 329 |
case 13: |
| 330 |
//else if (m < 0.7) |
| 331 |
{ |
| 332 |
constexpr T coef[] = |
| 333 |
{ |
| 334 |
static_cast<T>(1.270707479650149744), |
| 335 |
-static_cast<T>(0.566839168287866583), |
| 336 |
-static_cast<T>(0.262160793432492598), |
| 337 |
-static_cast<T>(0.292244173533077419), |
| 338 |
-static_cast<T>(0.440397840850423189), |
| 339 |
-static_cast<T>(0.774947641381397458), |
| 340 |
-static_cast<T>(1.498870837987561088), |
| 341 |
-static_cast<T>(3.089708310445186667), |
| 342 |
-static_cast<T>(6.667595903381001064), |
| 343 |
-static_cast<T>(14.89436036517319078), |
| 344 |
-static_cast<T>(34.18120574251449024), |
| 345 |
-static_cast<T>(80.15895841905397306), |
| 346 |
-static_cast<T>(191.3489480762984920), |
| 347 |
-static_cast<T>(463.5938853480342030), |
| 348 |
-static_cast<T>(1137.380822169360061) |
| 349 |
}; |
| 350 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.65)); |
| 351 |
} |
| 352 |
case 14: |
| 353 |
case 15: |
| 354 |
//else if (m < 0.8) |
| 355 |
{ |
| 356 |
constexpr T coef[] = |
| 357 |
{ |
| 358 |
static_cast<T>(1.211056027568459525), |
| 359 |
-static_cast<T>(0.630306413287455807), |
| 360 |
-static_cast<T>(0.387166409520669145), |
| 361 |
-static_cast<T>(0.592278235311934603), |
| 362 |
-static_cast<T>(1.237555584513049844), |
| 363 |
-static_cast<T>(3.032056661745247199), |
| 364 |
-static_cast<T>(8.181688221573590762), |
| 365 |
-static_cast<T>(23.55507217389693250), |
| 366 |
-static_cast<T>(71.04099935893064956), |
| 367 |
-static_cast<T>(221.8796853192349888), |
| 368 |
-static_cast<T>(712.1364793277635425), |
| 369 |
-static_cast<T>(2336.125331440396407), |
| 370 |
-static_cast<T>(7801.945954775964673), |
| 371 |
-static_cast<T>(26448.19586059191933), |
| 372 |
-static_cast<T>(90799.48341621365251), |
| 373 |
-static_cast<T>(315126.0406449163424), |
| 374 |
-static_cast<T>(1104011.344311591159) |
| 375 |
}; |
| 376 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.75)); |
| 377 |
} |
| 378 |
case 16: |
| 379 |
//else if (m < 0.85) |
| 380 |
{ |
| 381 |
constexpr T coef[] = |
| 382 |
{ |
| 383 |
static_cast<T>(1.161307152196282836), |
| 384 |
-static_cast<T>(0.701100284555289548), |
| 385 |
-static_cast<T>(0.580551474465437362), |
| 386 |
-static_cast<T>(1.243693061077786614), |
| 387 |
-static_cast<T>(3.679383613496634879), |
| 388 |
-static_cast<T>(12.81590924337895775), |
| 389 |
-static_cast<T>(49.25672530759985272), |
| 390 |
-static_cast<T>(202.1818735434090269), |
| 391 |
-static_cast<T>(869.8602699308701437), |
| 392 |
-static_cast<T>(3877.005847313289571), |
| 393 |
-static_cast<T>(17761.70710170939814), |
| 394 |
-static_cast<T>(83182.69029154232061), |
| 395 |
-static_cast<T>(396650.4505013548170), |
| 396 |
-static_cast<T>(1920033.413682634405) |
| 397 |
}; |
| 398 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.825)); |
| 399 |
} |
| 400 |
case 17: |
| 401 |
//else if (m < 0.90) |
| 402 |
{ |
| 403 |
constexpr T coef[] = |
| 404 |
{ |
| 405 |
static_cast<T>(1.124617325119752213), |
| 406 |
-static_cast<T>(0.770845056360909542), |
| 407 |
-static_cast<T>(0.844794053644911362), |
| 408 |
-static_cast<T>(2.490097309450394453), |
| 409 |
-static_cast<T>(10.23971741154384360), |
| 410 |
-static_cast<T>(49.74900546551479866), |
| 411 |
-static_cast<T>(267.0986675195705196), |
| 412 |
-static_cast<T>(1532.665883825229947), |
| 413 |
-static_cast<T>(9222.313478526091951), |
| 414 |
-static_cast<T>(57502.51612140314030), |
| 415 |
-static_cast<T>(368596.1167416106063), |
| 416 |
-static_cast<T>(2415611.088701091428), |
| 417 |
-static_cast<T>(16120097.81581656797), |
| 418 |
-static_cast<T>(109209938.5203089915), |
| 419 |
-static_cast<T>(749380758.1942496220), |
| 420 |
-static_cast<T>(5198725846.725541393), |
| 421 |
-static_cast<T>(36409256888.12139973) |
| 422 |
}; |
| 423 |
return boost::math::tools::evaluate_polynomial(coef, m - static_cast<T>(0.875)); |
| 424 |
} |
| 425 |
default: |
| 426 |
// |
| 427 |
// All cases where m > 0.9 |
| 428 |
// including all error handling: |
| 429 |
// |
| 430 |
return ellint_e_imp(k, pol, boost::math::integral_constant<int, 2>()); |
| 431 |
} |
| 432 |
} |
| 433 |
template <typename T, typename Policy> |
| 434 |
BOOST_MATH_GPU_ENABLED BOOST_MATH_FORCEINLINE T ellint_e_imp(T k, const Policy& pol, boost::math::integral_constant<int, 1> const&) |
| 435 |
{ |
| 436 |
BOOST_MATH_STD_USING |
| 437 |
using namespace boost::math::tools; |
| 438 |
|
| 439 |
T m = k * k; |
| 440 |
switch (static_cast<int>(20 * m)) |
| 441 |
{ |
| 442 |
case 0: |
| 443 |
case 1: |
| 444 |
//if (m < 0.1) |
| 445 |
{ |
| 446 |
constexpr T coef[] = |
| 447 |
{ |
| 448 |
1.5509733517804723277L, |
| 449 |
-0.40030102010319852390L, |
| 450 |
-0.078498619442941939212L, |
| 451 |
-0.034318853117591992417L, |
| 452 |
-0.019718043317365499309L, |
| 453 |
-0.013059507731993309191L, |
| 454 |
-0.0094423728741465473894L, |
| 455 |
-0.0072467285124021568126L, |
| 456 |
-0.0058074240129560897940L, |
| 457 |
-0.0048091877860093381762L, |
| 458 |
-0.0040863992332551506768L, |
| 459 |
-0.0035450302604139562644L, |
| 460 |
-0.0031283511188028336315L |
| 461 |
}; |
| 462 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.05L); |
| 463 |
} |
| 464 |
case 2: |
| 465 |
case 3: |
| 466 |
//else if (m < 0.2) |
| 467 |
{ |
| 468 |
constexpr T coef[] = |
| 469 |
{ |
| 470 |
1.5101218320928197276L, |
| 471 |
-0.41711633390586754922L, |
| 472 |
-0.090123820404774568894L, |
| 473 |
-0.043729944019084311555L, |
| 474 |
-0.027965493064761784548L, |
| 475 |
-0.020644781177568105268L, |
| 476 |
-0.016650786739707238037L, |
| 477 |
-0.014261960828842519634L, |
| 478 |
-0.012759847429264802627L, |
| 479 |
-0.011799303775587354169L, |
| 480 |
-0.011197445703074968018L, |
| 481 |
-0.010850368064799902735L, |
| 482 |
-0.010696133481060989818L |
| 483 |
}; |
| 484 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.15L); |
| 485 |
} |
| 486 |
case 4: |
| 487 |
case 5: |
| 488 |
//else if (m < 0.3L) |
| 489 |
{ |
| 490 |
constexpr T coef[] = |
| 491 |
{ |
| 492 |
1.4674622093394271555L, |
| 493 |
-0.43657629094633777482L, |
| 494 |
-0.10515555766694255399L, |
| 495 |
-0.057371843593241729895L, |
| 496 |
-0.041391627727340220236L, |
| 497 |
-0.034527728505280841188L, |
| 498 |
-0.031495443512532782647L, |
| 499 |
-0.030527000890325277179L, |
| 500 |
-0.030916984019238900349L, |
| 501 |
-0.032371395314758122268L, |
| 502 |
-0.034789960386404158240L, |
| 503 |
-0.038182654612387881967L, |
| 504 |
-0.042636187648900252525L, |
| 505 |
-0.048302272505241634467 |
| 506 |
}; |
| 507 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.25L); |
| 508 |
} |
| 509 |
case 6: |
| 510 |
case 7: |
| 511 |
//else if (m < 0.4L) |
| 512 |
{ |
| 513 |
constexpr T coef[] = |
| 514 |
{ |
| 515 |
1.4226911334908791711L, |
| 516 |
-0.45951351962104867394L, |
| 517 |
-0.12525053982206187849L, |
| 518 |
-0.078138545094409477156L, |
| 519 |
-0.064714278472050001838L, |
| 520 |
-0.062084339131730310707L, |
| 521 |
-0.065197032815572476910L, |
| 522 |
-0.072793895362578779473L, |
| 523 |
-0.084959075171781003264L, |
| 524 |
-0.10253985013104599679L, |
| 525 |
-0.12705358515769603644L, |
| 526 |
-0.16079112069127460621L, |
| 527 |
-0.20705400012405941376L, |
| 528 |
-0.27053164884730888948L |
| 529 |
}; |
| 530 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.35L); |
| 531 |
} |
| 532 |
case 8: |
| 533 |
case 9: |
| 534 |
//else if (m < 0.5L) |
| 535 |
{ |
| 536 |
constexpr T coef[] = |
| 537 |
{ |
| 538 |
1.3754019718711162908L, |
| 539 |
-0.48720218327318483652L, |
| 540 |
-0.15331170134854022753L, |
| 541 |
-0.11184944491702783273L, |
| 542 |
-0.10884095252313576755L, |
| 543 |
-0.12295422312026907610L, |
| 544 |
-0.15221716396203504746L, |
| 545 |
-0.20049532364269733857L, |
| 546 |
-0.27617433306775175837L, |
| 547 |
-0.39351311430437585139L, |
| 548 |
-0.57575440602787914711L, |
| 549 |
-0.86052323572723975634L, |
| 550 |
-1.3088332057585401616L, |
| 551 |
-2.0200280559452241745L, |
| 552 |
-3.1566019548237606451L |
| 553 |
}; |
| 554 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.45L); |
| 555 |
} |
| 556 |
case 10: |
| 557 |
case 11: |
| 558 |
//else if (m < 0.6L) |
| 559 |
{ |
| 560 |
constexpr T coef[] = |
| 561 |
{ |
| 562 |
1.3250244979582300818L, |
| 563 |
-0.52172764755756676713L, |
| 564 |
-0.19490643048212621262L, |
| 565 |
-0.17162372682201126365L, |
| 566 |
-0.20275465292641914128L, |
| 567 |
-0.27879895311853476205L, |
| 568 |
-0.42069845728100576224L, |
| 569 |
-0.67594840085310602110L, |
| 570 |
-1.1363431218392292440L, |
| 571 |
-1.9767211439543982613L, |
| 572 |
-3.5316967730957225064L, |
| 573 |
-6.4467536401560481499L, |
| 574 |
-11.977031302088840261L, |
| 575 |
-22.581360948073964469L, |
| 576 |
-43.109479829481450573L, |
| 577 |
-83.186290908288807424L |
| 578 |
}; |
| 579 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.55L); |
| 580 |
} |
| 581 |
case 12: |
| 582 |
case 13: |
| 583 |
//else if (m < 0.7L) |
| 584 |
{ |
| 585 |
constexpr T coef[] = |
| 586 |
{ |
| 587 |
1.2707074796501497440L, |
| 588 |
-0.56683916828786658286L, |
| 589 |
-0.26216079343249259779L, |
| 590 |
-0.29224417353307741931L, |
| 591 |
-0.44039784085042318909L, |
| 592 |
-0.77494764138139745824L, |
| 593 |
-1.4988708379875610880L, |
| 594 |
-3.0897083104451866665L, |
| 595 |
-6.6675959033810010645L, |
| 596 |
-14.894360365173190775L, |
| 597 |
-34.181205742514490240L, |
| 598 |
-80.158958419053973056L, |
| 599 |
-191.34894807629849204L, |
| 600 |
-463.59388534803420301L, |
| 601 |
-1137.3808221693600606L, |
| 602 |
-2820.7073786352269339L, |
| 603 |
-7061.1382244658715621L, |
| 604 |
-17821.809331816437058L, |
| 605 |
-45307.849987201897801L |
| 606 |
}; |
| 607 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.65L); |
| 608 |
} |
| 609 |
case 14: |
| 610 |
case 15: |
| 611 |
//else if (m < 0.8L) |
| 612 |
{ |
| 613 |
constexpr T coef[] = |
| 614 |
{ |
| 615 |
1.2110560275684595248L, |
| 616 |
-0.63030641328745580709L, |
| 617 |
-0.38716640952066914514L, |
| 618 |
-0.59227823531193460257L, |
| 619 |
-1.2375555845130498445L, |
| 620 |
-3.0320566617452471986L, |
| 621 |
-8.1816882215735907624L, |
| 622 |
-23.555072173896932503L, |
| 623 |
-71.040999358930649565L, |
| 624 |
-221.87968531923498875L, |
| 625 |
-712.13647932776354253L, |
| 626 |
-2336.1253314403964072L, |
| 627 |
-7801.9459547759646726L, |
| 628 |
-26448.195860591919335L, |
| 629 |
-90799.483416213652512L, |
| 630 |
-315126.04064491634241L, |
| 631 |
-1.1040113443115911589e6L, |
| 632 |
-3.8998018348056769095e6L, |
| 633 |
-1.3876249116223745041e7L, |
| 634 |
-4.9694982823537861149e7L, |
| 635 |
-1.7900668836197342979e8L, |
| 636 |
-6.4817399873722371964e8L |
| 637 |
}; |
| 638 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.75L); |
| 639 |
} |
| 640 |
case 16: |
| 641 |
//else if (m < 0.85L) |
| 642 |
{ |
| 643 |
constexpr T coef[] = |
| 644 |
{ |
| 645 |
1.1613071521962828360L, |
| 646 |
-0.70110028455528954752L, |
| 647 |
-0.58055147446543736163L, |
| 648 |
-1.2436930610777866138L, |
| 649 |
-3.6793836134966348789L, |
| 650 |
-12.815909243378957753L, |
| 651 |
-49.256725307599852720L, |
| 652 |
-202.18187354340902693L, |
| 653 |
-869.86026993087014372L, |
| 654 |
-3877.0058473132895713L, |
| 655 |
-17761.707101709398174L, |
| 656 |
-83182.690291542320614L, |
| 657 |
-396650.45050135481698L, |
| 658 |
-1.9200334136826344054e6L, |
| 659 |
-9.4131321779500838352e6L, |
| 660 |
-4.6654858837335370627e7L, |
| 661 |
-2.3343549352617609390e8L, |
| 662 |
-1.1776928223045913454e9L, |
| 663 |
-5.9850851892915740401e9L, |
| 664 |
-3.0614702984618644983e10L |
| 665 |
}; |
| 666 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.825L); |
| 667 |
} |
| 668 |
case 17: |
| 669 |
//else if (m < 0.90L) |
| 670 |
{ |
| 671 |
constexpr T coef[] = |
| 672 |
{ |
| 673 |
1.1246173251197522132L, |
| 674 |
-0.77084505636090954218L, |
| 675 |
-0.84479405364491136236L, |
| 676 |
-2.4900973094503944527L, |
| 677 |
-10.239717411543843601L, |
| 678 |
-49.749005465514798660L, |
| 679 |
-267.09866751957051961L, |
| 680 |
-1532.6658838252299468L, |
| 681 |
-9222.3134785260919507L, |
| 682 |
-57502.516121403140303L, |
| 683 |
-368596.11674161060626L, |
| 684 |
-2.4156110887010914281e6L, |
| 685 |
-1.6120097815816567971e7L, |
| 686 |
-1.0920993852030899148e8L, |
| 687 |
-7.4938075819424962198e8L, |
| 688 |
-5.1987258467255413931e9L, |
| 689 |
-3.6409256888121399726e10L, |
| 690 |
-2.5711802891217393544e11L, |
| 691 |
-1.8290904062978796996e12L, |
| 692 |
-1.3096838781743248404e13L, |
| 693 |
-9.4325465851415135118e13L, |
| 694 |
-6.8291980829471896669e14L |
| 695 |
}; |
| 696 |
return boost::math::tools::evaluate_polynomial(coef, m - 0.875L); |
| 697 |
} |
| 698 |
default: |
| 699 |
// |
| 700 |
// All cases where m > 0.9 |
| 701 |
// including all error handling: |
| 702 |
// |
| 703 |
return ellint_e_imp(k, pol, boost::math::integral_constant<int, 2>()); |
| 704 |
} |
| 705 |
} |
| 706 |
|
| 707 |
template <typename T, typename Policy> |
| 708 |
BOOST_MATH_GPU_ENABLED typename tools::promote_args<T>::type ellint_2(T k, const Policy& pol, const boost::math::true_type&) |
| 709 |
{ |
| 710 |
typedef typename tools::promote_args<T>::type result_type; |
| 711 |
typedef typename policies::evaluation<result_type, Policy>::type value_type; |
| 712 |
typedef boost::math::integral_constant<int, |
| 713 |
boost::math::is_floating_point<T>::value&& boost::math::numeric_limits<T>::digits && (boost::math::numeric_limits<T>::digits <= 54) ? 0 : |
| 714 |
boost::math::is_floating_point<T>::value && boost::math::numeric_limits<T>::digits && (boost::math::numeric_limits<T>::digits <= 64) ? 1 : 2 |
| 715 |
> precision_tag_type; |
| 716 |
return policies::checked_narrowing_cast<result_type, Policy>(detail::ellint_e_imp(static_cast<value_type>(k), pol, precision_tag_type()), "boost::math::ellint_2<%1%>(%1%)"); |
| 717 |
} |
| 718 |
|
| 719 |
// Elliptic integral (Legendre form) of the second kind |
| 720 |
template <class T1, class T2> |
| 721 |
BOOST_MATH_GPU_ENABLED typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const boost::math::false_type&) |
| 722 |
{ |
| 723 |
return boost::math::ellint_2(k, phi, policies::policy<>()); |
| 724 |
} |
| 725 |
|
| 726 |
} // detail |
| 727 |
|
| 728 |
// Elliptic integral (Legendre form) of the second kind |
| 729 |
template <class T1, class T2> |
| 730 |
BOOST_MATH_GPU_ENABLED typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi) |
| 731 |
{ |
| 732 |
typedef typename policies::is_policy<T2>::type tag_type; |
| 733 |
return detail::ellint_2(k, phi, tag_type()); |
| 734 |
} |
| 735 |
|
| 736 |
template <class T1, class T2, class Policy> |
| 737 |
BOOST_MATH_GPU_ENABLED typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol) // LCOV_EXCL_LINE gcc misses this but sees the function body, strange! |
| 738 |
{ |
| 739 |
typedef typename tools::promote_args<T1, T2>::type result_type; |
| 740 |
typedef typename policies::evaluation<result_type, Policy>::type value_type; |
| 741 |
return policies::checked_narrowing_cast<result_type, Policy>(detail::ellint_e_imp(static_cast<value_type>(phi), static_cast<value_type>(k), pol), "boost::math::ellint_2<%1%>(%1%,%1%)"); |
| 742 |
} |
| 743 |
|
| 744 |
|
| 745 |
// Complete elliptic integral (Legendre form) of the second kind |
| 746 |
template <typename T> |
| 747 |
BOOST_MATH_GPU_ENABLED typename tools::promote_args<T>::type ellint_2(T k) |
| 748 |
{ |
| 749 |
return ellint_2(k, policies::policy<>()); |
| 750 |
} |
| 751 |
|
| 752 |
|
| 753 |
}} // namespaces |
| 754 |
|
| 755 |
#endif // BOOST_MATH_ELLINT_2_HPP |
| 756 |
|