boost/math/special_functions/zeta.hpp

   1 //  Copyright John Maddock 2007.
   2 //  Use, modification and distribution are subject to the
   3 //  Boost Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef BOOST_MATH_ZETA_HPP
   7 #define BOOST_MATH_ZETA_HPP
   8
   9 #ifdef _MSC_VER
  10 #pragma once
  11 #endif
  12
  13 #include <boost/math/special_functions/math_fwd.hpp>
  14 #include <boost/math/tools/precision.hpp>
  15 #include <boost/math/tools/series.hpp>
  16 #include <boost/math/tools/big_constant.hpp>
  17 #include <boost/math/policies/error_handling.hpp>
  18 #include <boost/math/special_functions/gamma.hpp>
  19 #include <boost/math/special_functions/sin_pi.hpp>
  20
  21 namespace boost{ namespace math{ namespace detail{
  22
  23 #if 0
  24 //
  25 // This code is commented out because we have a better more rapidly converging series
  26 // now.  Retained for future reference and in case the new code causes any issues down the line....
  27 //
  28
  29 template <class T, class Policy>
  30 struct zeta_series_cache_size
  31 {
  32    //
  33    // Work how large to make our cache size when evaluating the series
  34    // evaluation:  normally this is just large enough for the series
  35    // to have converged, but for arbitrary precision types we need a
  36    // really large cache to achieve reasonable precision in a reasonable
  37    // time.  This is important when constructing rational approximations
  38    // to zeta for example.
  39    //
  40    typedef typename boost::math::policies::precision<T,Policy>::type precision_type;
  41    typedef typename mpl::if_<
  42       mpl::less_equal<precision_type, mpl::int_<0> >,
  43       mpl::int_<5000>,
  44       typename mpl::if_<
  45          mpl::less_equal<precision_type, mpl::int_<64> >,
  46          mpl::int_<70>,
  47          typename mpl::if_<
  48             mpl::less_equal<precision_type, mpl::int_<113> >,
  49             mpl::int_<100>,
  50             mpl::int_<5000>
  51          >::type
  52       >::type
  53    >::type type;
  54 };
  55
  56 template <class T, class Policy>
  57 T zeta_series_imp(T s, T sc, const Policy&)
  58 {
  59    //
  60    // Series evaluation from:
  61    // Havil, J. Gamma: Exploring Euler's Constant.
  62    // Princeton, NJ: Princeton University Press, 2003.
  63    //
  64    // See also http://mathworld.wolfram.com/RiemannZetaFunction.html
  65    //
  66    BOOST_MATH_STD_USING
  67    T sum = 0;
  68    T mult = 0.5;
  69    T change;
  70    typedef typename zeta_series_cache_size<T,Policy>::type cache_size;
  71    T powers[cache_size::value] = { 0, };
  72    unsigned n = 0;
  73    do{
  74       T binom = -static_cast<T>(n);
  75       T nested_sum = 1;
  76       if(n < sizeof(powers) / sizeof(powers[0]))
  77          powers[n] = pow(static_cast<T>(n + 1), -s);
  78       for(unsigned k = 1; k <= n; ++k)
  79       {
  80          T p;
  81          if(k < sizeof(powers) / sizeof(powers[0]))
  82          {
  83             p = powers[k];
  84             //p = pow(k + 1, -s);
  85          }
  86          else
  87             p = pow(static_cast<T>(k + 1), -s);
  88          nested_sum += binom * p;
  89         binom *= (k - static_cast<T>(n)) / (k + 1);
  90       }
  91       change = mult * nested_sum;
  92       sum += change;
  93       mult /= 2;
  94       ++n;
  95    }while(fabs(change / sum) > tools::epsilon<T>());
  96
  97    return sum * 1 / -boost::math::powm1(T(2), sc);
  98 }
  99
 100 //
 101 // Classical p-series:
 102 //
 103 template <class T>
 104 struct zeta_series2
 105 {
 106    typedef T result_type;
 107    zeta_series2(T _s) : s(-_s), k(1){}
 108    T operator()()
 109    {
 110       BOOST_MATH_STD_USING
 111       return pow(static_cast<T>(k++), s);
 112    }
 113 private:
 114    T s;
 115    unsigned k;
 116 };
 117
 118 template <class T, class Policy>
 119 inline T zeta_series2_imp(T s, const Policy& pol)
 120 {
 121    boost::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();;
 122    zeta_series2<T> f(s);
 123    T result = tools::sum_series(
 124       f,
 125       policies::get_epsilon<T, Policy>(),
 126       max_iter);
 127    policies::check_series_iterations<T>("boost::math::zeta_series2<%1%>(%1%)", max_iter, pol);
 128    return result;
 129 }
 130 #endif
 131
 132 template <class T, class Policy>
 133 T zeta_polynomial_series(T s, T sc, Policy const &)
 134 {
 135    //
 136    // This is algorithm 3 from:
 137    //
 138    // "An Efficient Algorithm for the Riemann Zeta Function", P. Borwein,
 139    // Canadian Mathematical Society, Conference Proceedings.
 140    // See: http://www.cecm.sfu.ca/personal/pborwein/PAPERS/P155.pdf
 141    //
 142    BOOST_MATH_STD_USING
 143    int n = itrunc(T(log(boost::math::tools::epsilon<T>()) / -2));
 144    T sum = 0;
 145    T two_n = ldexp(T(1), n);
 146    int ej_sign = 1;
 147    for(int j = 0; j < n; ++j)
 148    {
 149       sum += ej_sign * -two_n / pow(T(j + 1), s);
 150       ej_sign = -ej_sign;
 151    }
 152    T ej_sum = 1;
 153    T ej_term = 1;
 154    for(int j = n; j <= 2 * n - 1; ++j)
 155    {
 156       sum += ej_sign * (ej_sum - two_n) / pow(T(j + 1), s);
 157       ej_sign = -ej_sign;
 158       ej_term *= 2 * n - j;
 159       ej_term /= j - n + 1;
 160       ej_sum += ej_term;
 161    }
 162    return -sum / (two_n * (-powm1(T(2), sc)));
 163 }
 164
 165 template <class T, class Policy>
 166 T zeta_imp_prec(T s, T sc, const Policy& pol, const mpl::int_<0>&)
 167 {
 168    BOOST_MATH_STD_USING
 169    T result;
 170    result = zeta_polynomial_series(s, sc, pol);
 171 #if 0
 172    // Old code archived for future reference:
 173
 174    //
 175    // Only use power series if it will converge in 100
 176    // iterations or less: the more iterations it consumes
 177    // the slower convergence becomes so we have to be very
 178    // careful in it's usage.
 179    //
 180    if (s > -log(tools::epsilon<T>()) / 4.5)
 181       result = detail::zeta_series2_imp(s, pol);
 182    else
 183       result = detail::zeta_series_imp(s, sc, pol);
 184 #endif
 185    return result;
 186 }
 187
 188 template <class T, class Policy>
 189 inline T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<53>&)
 190 {
 191    BOOST_MATH_STD_USING
 192    T result;
 193    if(s < 1)
 194    {
 195       // Rational Approximation
 196       // Maximum Deviation Found:                     2.020e-18
 197       // Expected Error Term:                         -2.020e-18
 198       // Max error found at double precision:         3.994987e-17
 199       static const T P[6] = {
 200          0.24339294433593750202L,
 201          -0.49092470516353571651L,
 202          0.0557616214776046784287L,
 203          -0.00320912498879085894856L,
 204          0.000451534528645796438704L,
 205          -0.933241270357061460782e-5L,
 206         };
 207       static const T Q[6] = {
 208          1L,
 209          -0.279960334310344432495L,
 210          0.0419676223309986037706L,
 211          -0.00413421406552171059003L,
 212          0.00024978985622317935355L,
 213          -0.101855788418564031874e-4L,
 214       };
 215       result = tools::evaluate_polynomial(P, sc) / tools::evaluate_polynomial(Q, sc);
 216       result -= 1.2433929443359375F;
 217       result += (sc);
 218       result /= (sc);
 219    }
 220    else if(s <= 2)
 221    {
 222       // Maximum Deviation Found:        9.007e-20
 223       // Expected Error Term:            9.007e-20
 224       static const T P[6] = {
 225          0.577215664901532860516,
 226          0.243210646940107164097,
 227          0.0417364673988216497593,
 228          0.00390252087072843288378,
 229          0.000249606367151877175456,
 230          0.110108440976732897969e-4,
 231       };
 232       static const T Q[6] = {
 233          1,
 234          0.295201277126631761737,
 235          0.043460910607305495864,
 236          0.00434930582085826330659,
 237          0.000255784226140488490982,
 238          0.10991819782396112081e-4,
 239       };
 240       result = tools::evaluate_polynomial(P, T(-sc)) / tools::evaluate_polynomial(Q, T(-sc));
 241       result += 1 / (-sc);
 242    }
 243    else if(s <= 4)
 244    {
 245       // Maximum Deviation Found:          5.946e-22
 246       // Expected Error Term:              -5.946e-22
 247       static const float Y = 0.6986598968505859375;
 248       static const T P[6] = {
 249          -0.0537258300023595030676,
 250          0.0445163473292365591906,
 251          0.0128677673534519952905,
 252          0.00097541770457391752726,
 253          0.769875101573654070925e-4,
 254          0.328032510000383084155e-5,
 255       };
 256       static const T Q[7] = {
 257          1,
 258          0.33383194553034051422,
 259          0.0487798431291407621462,
 260          0.00479039708573558490716,
 261          0.000270776703956336357707,
 262          0.106951867532057341359e-4,
 263          0.236276623974978646399e-7,
 264       };
 265       result = tools::evaluate_polynomial(P, T(s - 2)) / tools::evaluate_polynomial(Q, T(s - 2));
 266       result += Y + 1 / (-sc);
 267    }
 268    else if(s <= 7)
 269    {
 270       // Maximum Deviation Found:                     2.955e-17
 271       // Expected Error Term:                         2.955e-17
 272       // Max error found at double precision:         2.009135e-16
 273
 274       static const T P[6] = {
 275          -2.49710190602259410021,
 276          -2.60013301809475665334,
 277          -0.939260435377109939261,
 278          -0.138448617995741530935,
 279          -0.00701721240549802377623,
 280          -0.229257310594893932383e-4,
 281       };
 282       static const T Q[9] = {
 283          1,
 284          0.706039025937745133628,
 285          0.15739599649558626358,
 286          0.0106117950976845084417,
 287          -0.36910273311764618902e-4,
 288          0.493409563927590008943e-5,
 289          -0.234055487025287216506e-6,
 290          0.718833729365459760664e-8,
 291          -0.1129200113474947419e-9,
 292       };
 293       result = tools::evaluate_polynomial(P, T(s - 4)) / tools::evaluate_polynomial(Q, T(s - 4));
 294       result = 1 + exp(result);
 295    }
 296    else if(s < 15)
 297    {
 298       // Maximum Deviation Found:                     7.117e-16
 299       // Expected Error Term:                         7.117e-16
 300       // Max error found at double precision:         9.387771e-16
 301       static const T P[7] = {
 302          -4.78558028495135619286,
 303          -1.89197364881972536382,
 304          -0.211407134874412820099,
 305          -0.000189204758260076688518,
 306          0.00115140923889178742086,
 307          0.639949204213164496988e-4,
 308          0.139348932445324888343e-5,
 309         };
 310       static const T Q[9] = {
 311          1,
 312          0.244345337378188557777,
 313          0.00873370754492288653669,
 314          -0.00117592765334434471562,
 315          -0.743743682899933180415e-4,
 316          -0.21750464515767984778e-5,
 317          0.471001264003076486547e-8,
 318          -0.833378440625385520576e-10,
 319          0.699841545204845636531e-12,
 320         };
 321       result = tools::evaluate_polynomial(P, T(s - 7)) / tools::evaluate_polynomial(Q, T(s - 7));
 322       result = 1 + exp(result);
 323    }
 324    else if(s < 36)
 325    {
 326       // Max error in interpolated form:             1.668e-17
 327       // Max error found at long double precision:   1.669714e-17
 328       static const T P[8] = {
 329          -10.3948950573308896825,
 330          -2.85827219671106697179,
 331          -0.347728266539245787271,
 332          -0.0251156064655346341766,
 333          -0.00119459173416968685689,
 334          -0.382529323507967522614e-4,
 335          -0.785523633796723466968e-6,
 336          -0.821465709095465524192e-8,
 337       };
 338       static const T Q[10] = {
 339          1,
 340          0.208196333572671890965,
 341          0.0195687657317205033485,
 342          0.00111079638102485921877,
 343          0.408507746266039256231e-4,
 344          0.955561123065693483991e-6,
 345          0.118507153474022900583e-7,
 346          0.222609483627352615142e-14,
 347       };
 348       result = tools::evaluate_polynomial(P, T(s - 15)) / tools::evaluate_polynomial(Q, T(s - 15));
 349       result = 1 + exp(result);
 350    }
 351    else if(s < 56)
 352    {
 353       result = 1 + pow(T(2), -s);
 354    }
 355    else
 356    {
 357       result = 1;
 358    }
 359    return result;
 360 }
 361
 362 template <class T, class Policy>
 363 T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<64>&)
 364 {
 365    BOOST_MATH_STD_USING
 366    T result;
 367    if(s < 1)
 368    {
 369       // Rational Approximation
 370       // Maximum Deviation Found:                     3.099e-20
 371       // Expected Error Term:                         3.099e-20
 372       // Max error found at long double precision:    5.890498e-20
 373       static const T P[6] = {
 374          BOOST_MATH_BIG_CONSTANT(T, 64, 0.243392944335937499969),
 375          BOOST_MATH_BIG_CONSTANT(T, 64, -0.496837806864865688082),
 376          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0680008039723709987107),
 377          BOOST_MATH_BIG_CONSTANT(T, 64, -0.00511620413006619942112),
 378          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000455369899250053003335),
 379          BOOST_MATH_BIG_CONSTANT(T, 64, -0.279496685273033761927e-4),
 380         };
 381       static const T Q[7] = {
 382          BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
 383          BOOST_MATH_BIG_CONSTANT(T, 64, -0.30425480068225790522),
 384          BOOST_MATH_BIG_CONSTANT(T, 64, 0.050052748580371598736),
 385          BOOST_MATH_BIG_CONSTANT(T, 64, -0.00519355671064700627862),
 386          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000360623385771198350257),
 387          BOOST_MATH_BIG_CONSTANT(T, 64, -0.159600883054550987633e-4),
 388          BOOST_MATH_BIG_CONSTANT(T, 64, 0.339770279812410586032e-6),
 389       };
 390       result = tools::evaluate_polynomial(P, sc) / tools::evaluate_polynomial(Q, sc);
 391       result -= 1.2433929443359375F;
 392       result += (sc);
 393       result /= (sc);
 394    }
 395    else if(s <= 2)
 396    {
 397       // Maximum Deviation Found:                     1.059e-21
 398       // Expected Error Term:                         1.059e-21
 399       // Max error found at long double precision:    1.626303e-19
 400
 401       static const T P[6] = {
 402          BOOST_MATH_BIG_CONSTANT(T, 64, 0.577215664901532860605),
 403          BOOST_MATH_BIG_CONSTANT(T, 64, 0.222537368917162139445),
 404          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0356286324033215682729),
 405          BOOST_MATH_BIG_CONSTANT(T, 64, 0.00304465292366350081446),
 406          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000178102511649069421904),
 407          BOOST_MATH_BIG_CONSTANT(T, 64, 0.700867470265983665042e-5),
 408       };
 409       static const T Q[7] = {
 410          BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
 411          BOOST_MATH_BIG_CONSTANT(T, 64, 0.259385759149531030085),
 412          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0373974962106091316854),
 413          BOOST_MATH_BIG_CONSTANT(T, 64, 0.00332735159183332820617),
 414          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000188690420706998606469),
 415          BOOST_MATH_BIG_CONSTANT(T, 64, 0.635994377921861930071e-5),
 416          BOOST_MATH_BIG_CONSTANT(T, 64, 0.226583954978371199405e-7),
 417       };
 418       result = tools::evaluate_polynomial(P, T(-sc)) / tools::evaluate_polynomial(Q, T(-sc));
 419       result += 1 / (-sc);
 420    }
 421    else if(s <= 4)
 422    {
 423       // Maximum Deviation Found:          5.946e-22
 424       // Expected Error Term:              -5.946e-22
 425       static const float Y = 0.6986598968505859375;
 426       static const T P[7] = {
 427          BOOST_MATH_BIG_CONSTANT(T, 64, -0.053725830002359501027),
 428          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0470551187571475844778),
 429          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0101339410415759517471),
 430          BOOST_MATH_BIG_CONSTANT(T, 64, 0.00100240326666092854528),
 431          BOOST_MATH_BIG_CONSTANT(T, 64, 0.685027119098122814867e-4),
 432          BOOST_MATH_BIG_CONSTANT(T, 64, 0.390972820219765942117e-5),
 433          BOOST_MATH_BIG_CONSTANT(T, 64, 0.540319769113543934483e-7),
 434       };
 435       static const T Q[8] = {
 436          BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
 437          BOOST_MATH_BIG_CONSTANT(T, 64, 0.286577739726542730421),
 438          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0447355811517733225843),
 439          BOOST_MATH_BIG_CONSTANT(T, 64, 0.00430125107610252363302),
 440          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000284956969089786662045),
 441          BOOST_MATH_BIG_CONSTANT(T, 64, 0.116188101609848411329e-4),
 442          BOOST_MATH_BIG_CONSTANT(T, 64, 0.278090318191657278204e-6),
 443          BOOST_MATH_BIG_CONSTANT(T, 64, -0.19683620233222028478e-8),
 444       };
 445       result = tools::evaluate_polynomial(P, T(s - 2)) / tools::evaluate_polynomial(Q, T(s - 2));
 446       result += Y + 1 / (-sc);
 447    }
 448    else if(s <= 7)
 449    {
 450       // Max error found at long double precision: 8.132216e-19
 451       static const T P[8] = {
 452          BOOST_MATH_BIG_CONSTANT(T, 64, -2.49710190602259407065),
 453          BOOST_MATH_BIG_CONSTANT(T, 64, -3.36664913245960625334),
 454          BOOST_MATH_BIG_CONSTANT(T, 64, -1.77180020623777595452),
 455          BOOST_MATH_BIG_CONSTANT(T, 64, -0.464717885249654313933),
 456          BOOST_MATH_BIG_CONSTANT(T, 64, -0.0643694921293579472583),
 457          BOOST_MATH_BIG_CONSTANT(T, 64, -0.00464265386202805715487),
 458          BOOST_MATH_BIG_CONSTANT(T, 64, -0.000165556579779704340166),
 459          BOOST_MATH_BIG_CONSTANT(T, 64, -0.252884970740994069582e-5),
 460       };
 461       static const T Q[9] = {
 462          BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
 463          BOOST_MATH_BIG_CONSTANT(T, 64, 1.01300131390690459085),
 464          BOOST_MATH_BIG_CONSTANT(T, 64, 0.387898115758643503827),
 465          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0695071490045701135188),
 466          BOOST_MATH_BIG_CONSTANT(T, 64, 0.00586908595251442839291),
 467          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000217752974064612188616),
 468          BOOST_MATH_BIG_CONSTANT(T, 64, 0.397626583349419011731e-5),
 469          BOOST_MATH_BIG_CONSTANT(T, 64, -0.927884739284359700764e-8),
 470          BOOST_MATH_BIG_CONSTANT(T, 64, 0.119810501805618894381e-9),
 471       };
 472       result = tools::evaluate_polynomial(P, T(s - 4)) / tools::evaluate_polynomial(Q, T(s - 4));
 473       result = 1 + exp(result);
 474    }
 475    else if(s < 15)
 476    {
 477       // Max error in interpolated form:              1.133e-18
 478       // Max error found at long double precision:    2.183198e-18
 479       static const T P[9] = {
 480          BOOST_MATH_BIG_CONSTANT(T, 64, -4.78558028495135548083),
 481          BOOST_MATH_BIG_CONSTANT(T, 64, -3.23873322238609358947),
 482          BOOST_MATH_BIG_CONSTANT(T, 64, -0.892338582881021799922),
 483          BOOST_MATH_BIG_CONSTANT(T, 64, -0.131326296217965913809),
 484          BOOST_MATH_BIG_CONSTANT(T, 64, -0.0115651591773783712996),
 485          BOOST_MATH_BIG_CONSTANT(T, 64, -0.000657728968362695775205),
 486          BOOST_MATH_BIG_CONSTANT(T, 64, -0.252051328129449973047e-4),
 487          BOOST_MATH_BIG_CONSTANT(T, 64, -0.626503445372641798925e-6),
 488          BOOST_MATH_BIG_CONSTANT(T, 64, -0.815696314790853893484e-8),
 489         };
 490       static const T Q[9] = {
 491          BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
 492          BOOST_MATH_BIG_CONSTANT(T, 64, 0.525765665400123515036),
 493          BOOST_MATH_BIG_CONSTANT(T, 64, 0.10852641753657122787),
 494          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0115669945375362045249),
 495          BOOST_MATH_BIG_CONSTANT(T, 64, 0.000732896513858274091966),
 496          BOOST_MATH_BIG_CONSTANT(T, 64, 0.30683952282420248448e-4),
 497          BOOST_MATH_BIG_CONSTANT(T, 64, 0.819649214609633126119e-6),
 498          BOOST_MATH_BIG_CONSTANT(T, 64, 0.117957556472335968146e-7),
 499          BOOST_MATH_BIG_CONSTANT(T, 64, -0.193432300973017671137e-12),
 500         };
 501       result = tools::evaluate_polynomial(P, T(s - 7)) / tools::evaluate_polynomial(Q, T(s - 7));
 502       result = 1 + exp(result);
 503    }
 504    else if(s < 42)
 505    {
 506       // Max error in interpolated form:             1.668e-17
 507       // Max error found at long double precision:   1.669714e-17
 508       static const T P[9] = {
 509          BOOST_MATH_BIG_CONSTANT(T, 64, -10.3948950573308861781),
 510          BOOST_MATH_BIG_CONSTANT(T, 64, -2.82646012777913950108),
 511          BOOST_MATH_BIG_CONSTANT(T, 64, -0.342144362739570333665),
 512          BOOST_MATH_BIG_CONSTANT(T, 64, -0.0249285145498722647472),
 513          BOOST_MATH_BIG_CONSTANT(T, 64, -0.00122493108848097114118),
 514          BOOST_MATH_BIG_CONSTANT(T, 64, -0.423055371192592850196e-4),
 515          BOOST_MATH_BIG_CONSTANT(T, 64, -0.1025215577185967488e-5),
 516          BOOST_MATH_BIG_CONSTANT(T, 64, -0.165096762663509467061e-7),
 517          BOOST_MATH_BIG_CONSTANT(T, 64, -0.145392555873022044329e-9),
 518       };
 519       static const T Q[10] = {
 520          BOOST_MATH_BIG_CONSTANT(T, 64, 1.0),
 521          BOOST_MATH_BIG_CONSTANT(T, 64, 0.205135978585281988052),
 522          BOOST_MATH_BIG_CONSTANT(T, 64, 0.0192359357875879453602),
 523          BOOST_MATH_BIG_CONSTANT(T, 64, 0.00111496452029715514119),
 524          BOOST_MATH_BIG_CONSTANT(T, 64, 0.434928449016693986857e-4),
 525          BOOST_MATH_BIG_CONSTANT(T, 64, 0.116911068726610725891e-5),
 526          BOOST_MATH_BIG_CONSTANT(T, 64, 0.206704342290235237475e-7),
 527          BOOST_MATH_BIG_CONSTANT(T, 64, 0.209772836100827647474e-9),
 528          BOOST_MATH_BIG_CONSTANT(T, 64, -0.939798249922234703384e-16),
 529          BOOST_MATH_BIG_CONSTANT(T, 64, 0.264584017421245080294e-18),
 530       };
 531       result = tools::evaluate_polynomial(P, T(s - 15)) / tools::evaluate_polynomial(Q, T(s - 15));
 532       result = 1 + exp(result);
 533    }
 534    else if(s < 63)
 535    {
 536       result = 1 + pow(T(2), -s);
 537    }
 538    else
 539    {
 540       result = 1;
 541    }
 542    return result;
 543 }
 544
 545 template <class T, class Policy>
 546 T zeta_imp_prec(T s, T sc, const Policy&, const mpl::int_<113>&)
 547 {
 548    BOOST_MATH_STD_USING
 549    T result;
 550    if(s < 1)
 551    {
 552       // Rational Approximation
 553       // Maximum Deviation Found:                     9.493e-37
 554       // Expected Error Term:                         9.492e-37
 555       // Max error found at long double precision:    7.281332e-31
 556
 557       static const T P[10] = {
 558          BOOST_MATH_BIG_CONSTANT(T, 113, -1.0),
 559          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0353008629988648122808504280990313668),
 560          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0107795651204927743049369868548706909),
 561          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000523961870530500751114866884685172975),
 562          BOOST_MATH_BIG_CONSTANT(T, 113, -0.661805838304910731947595897966487515e-4),
 563          BOOST_MATH_BIG_CONSTANT(T, 113, -0.658932670403818558510656304189164638e-5),
 564          BOOST_MATH_BIG_CONSTANT(T, 113, -0.103437265642266106533814021041010453e-6),
 565          BOOST_MATH_BIG_CONSTANT(T, 113, 0.116818787212666457105375746642927737e-7),
 566          BOOST_MATH_BIG_CONSTANT(T, 113, 0.660690993901506912123512551294239036e-9),
 567          BOOST_MATH_BIG_CONSTANT(T, 113, 0.113103113698388531428914333768142527e-10),
 568         };
 569       static const T Q[11] = {
 570          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 571          BOOST_MATH_BIG_CONSTANT(T, 113, -0.387483472099602327112637481818565459),
 572          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0802265315091063135271497708694776875),
 573          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0110727276164171919280036408995078164),
 574          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00112552716946286252000434849173787243),
 575          BOOST_MATH_BIG_CONSTANT(T, 113, -0.874554160748626916455655180296834352e-4),
 576          BOOST_MATH_BIG_CONSTANT(T, 113, 0.530097847491828379568636739662278322e-5),
 577          BOOST_MATH_BIG_CONSTANT(T, 113, -0.248461553590496154705565904497247452e-6),
 578          BOOST_MATH_BIG_CONSTANT(T, 113, 0.881834921354014787309644951507523899e-8),
 579          BOOST_MATH_BIG_CONSTANT(T, 113, -0.217062446168217797598596496310953025e-9),
 580          BOOST_MATH_BIG_CONSTANT(T, 113, 0.315823200002384492377987848307151168e-11),
 581       };
 582       result = tools::evaluate_polynomial(P, sc) / tools::evaluate_polynomial(Q, sc);
 583       result += (sc);
 584       result /= (sc);
 585    }
 586    else if(s <= 2)
 587    {
 588       // Maximum Deviation Found:                     1.616e-37
 589       // Expected Error Term:                         -1.615e-37
 590
 591       static const T P[10] = {
 592          BOOST_MATH_BIG_CONSTANT(T, 113, 0.577215664901532860606512090082402431),
 593          BOOST_MATH_BIG_CONSTANT(T, 113, 0.255597968739771510415479842335906308),
 594          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0494056503552807274142218876983542205),
 595          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00551372778611700965268920983472292325),
 596          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00043667616723970574871427830895192731),
 597          BOOST_MATH_BIG_CONSTANT(T, 113, 0.268562259154821957743669387915239528e-4),
 598          BOOST_MATH_BIG_CONSTANT(T, 113, 0.109249633923016310141743084480436612e-5),
 599          BOOST_MATH_BIG_CONSTANT(T, 113, 0.273895554345300227466534378753023924e-7),
 600          BOOST_MATH_BIG_CONSTANT(T, 113, 0.583103205551702720149237384027795038e-9),
 601          BOOST_MATH_BIG_CONSTANT(T, 113, -0.835774625259919268768735944711219256e-11),
 602       };
 603       static const T Q[11] = {
 604          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 605          BOOST_MATH_BIG_CONSTANT(T, 113, 0.316661751179735502065583176348292881),
 606          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0540401806533507064453851182728635272),
 607          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00598621274107420237785899476374043797),
 608          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000474907812321704156213038740142079615),
 609          BOOST_MATH_BIG_CONSTANT(T, 113, 0.272125421722314389581695715835862418e-4),
 610          BOOST_MATH_BIG_CONSTANT(T, 113, 0.112649552156479800925522445229212933e-5),
 611          BOOST_MATH_BIG_CONSTANT(T, 113, 0.301838975502992622733000078063330461e-7),
 612          BOOST_MATH_BIG_CONSTANT(T, 113, 0.422960728687211282539769943184270106e-9),
 613          BOOST_MATH_BIG_CONSTANT(T, 113, -0.377105263588822468076813329270698909e-11),
 614          BOOST_MATH_BIG_CONSTANT(T, 113, -0.581926559304525152432462127383600681e-13),
 615       };
 616       result = tools::evaluate_polynomial(P, T(-sc)) / tools::evaluate_polynomial(Q, T(-sc));
 617       result += 1 / (-sc);
 618    }
 619    else if(s <= 4)
 620    {
 621       // Maximum Deviation Found:                     1.891e-36
 622       // Expected Error Term:                         -1.891e-36
 623       // Max error found: 2.171527e-35
 624
 625       static const float Y = 0.6986598968505859375;
 626       static const T P[11] = {
 627          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0537258300023595010275848333539748089),
 628          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0429086930802630159457448174466342553),
 629          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0136148228754303412510213395034056857),
 630          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00190231601036042925183751238033763915),
 631          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000186880390916311438818302549192456581),
 632          BOOST_MATH_BIG_CONSTANT(T, 113, 0.145347370745893262394287982691323657e-4),
 633          BOOST_MATH_BIG_CONSTANT(T, 113, 0.805843276446813106414036600485884885e-6),
 634          BOOST_MATH_BIG_CONSTANT(T, 113, 0.340818159286739137503297172091882574e-7),
 635          BOOST_MATH_BIG_CONSTANT(T, 113, 0.115762357488748996526167305116837246e-8),
 636          BOOST_MATH_BIG_CONSTANT(T, 113, 0.231904754577648077579913403645767214e-10),
 637          BOOST_MATH_BIG_CONSTANT(T, 113, 0.340169592866058506675897646629036044e-12),
 638       };
 639       static const T Q[12] = {
 640          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 641          BOOST_MATH_BIG_CONSTANT(T, 113, 0.363755247765087100018556983050520554),
 642          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0696581979014242539385695131258321598),
 643          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00882208914484611029571547753782014817),
 644          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000815405623261946661762236085660996718),
 645          BOOST_MATH_BIG_CONSTANT(T, 113, 0.571366167062457197282642344940445452e-4),
 646          BOOST_MATH_BIG_CONSTANT(T, 113, 0.309278269271853502353954062051797838e-5),
 647          BOOST_MATH_BIG_CONSTANT(T, 113, 0.12822982083479010834070516053794262e-6),
 648          BOOST_MATH_BIG_CONSTANT(T, 113, 0.397876357325018976733953479182110033e-8),
 649          BOOST_MATH_BIG_CONSTANT(T, 113, 0.8484432107648683277598472295289279e-10),
 650          BOOST_MATH_BIG_CONSTANT(T, 113, 0.105677416606909614301995218444080615e-11),
 651          BOOST_MATH_BIG_CONSTANT(T, 113, 0.547223964564003701979951154093005354e-15),
 652       };
 653       result = tools::evaluate_polynomial(P, T(s - 2)) / tools::evaluate_polynomial(Q, T(s - 2));
 654       result += Y + 1 / (-sc);
 655    }
 656    else if(s <= 6)
 657    {
 658       // Max error in interpolated form:             1.510e-37
 659       // Max error found at long double precision:   2.769266e-34
 660
 661       static const T Y = 3.28348541259765625F;
 662
 663       static const T P[13] = {
 664          BOOST_MATH_BIG_CONSTANT(T, 113, 0.786383506575062179339611614117697622),
 665          BOOST_MATH_BIG_CONSTANT(T, 113, 0.495766593395271370974685959652073976),
 666          BOOST_MATH_BIG_CONSTANT(T, 113, -0.409116737851754766422360889037532228),
 667          BOOST_MATH_BIG_CONSTANT(T, 113, -0.57340744006238263817895456842655987),
 668          BOOST_MATH_BIG_CONSTANT(T, 113, -0.280479899797421910694892949057963111),
 669          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0753148409447590257157585696212649869),
 670          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0122934003684672788499099362823748632),
 671          BOOST_MATH_BIG_CONSTANT(T, 113, -0.00126148398446193639247961370266962927),
 672          BOOST_MATH_BIG_CONSTANT(T, 113, -0.828465038179772939844657040917364896e-4),
 673          BOOST_MATH_BIG_CONSTANT(T, 113, -0.361008916706050977143208468690645684e-5),
 674          BOOST_MATH_BIG_CONSTANT(T, 113, -0.109879825497910544424797771195928112e-6),
 675          BOOST_MATH_BIG_CONSTANT(T, 113, -0.214539416789686920918063075528797059e-8),
 676          BOOST_MATH_BIG_CONSTANT(T, 113, -0.15090220092460596872172844424267351e-10),
 677       };
 678       static const T Q[14] = {
 679          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 680          BOOST_MATH_BIG_CONSTANT(T, 113, 1.69490865837142338462982225731926485),
 681          BOOST_MATH_BIG_CONSTANT(T, 113, 1.22697696630994080733321401255942464),
 682          BOOST_MATH_BIG_CONSTANT(T, 113, 0.495409420862526540074366618006341533),
 683          BOOST_MATH_BIG_CONSTANT(T, 113, 0.122368084916843823462872905024259633),
 684          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0191412993625268971656513890888208623),
 685          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00191401538628980617753082598351559642),
 686          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000123318142456272424148930280876444459),
 687          BOOST_MATH_BIG_CONSTANT(T, 113, 0.531945488232526067889835342277595709e-5),
 688          BOOST_MATH_BIG_CONSTANT(T, 113, 0.161843184071894368337068779669116236e-6),
 689          BOOST_MATH_BIG_CONSTANT(T, 113, 0.305796079600152506743828859577462778e-8),
 690          BOOST_MATH_BIG_CONSTANT(T, 113, 0.233582592298450202680170811044408894e-10),
 691          BOOST_MATH_BIG_CONSTANT(T, 113, -0.275363878344548055574209713637734269e-13),
 692          BOOST_MATH_BIG_CONSTANT(T, 113, 0.221564186807357535475441900517843892e-15),
 693       };
 694       result = tools::evaluate_polynomial(P, T(s - 4)) / tools::evaluate_polynomial(Q, T(s - 4));
 695       result -= Y;
 696       result = 1 + exp(result);
 697    }
 698    else if(s < 10)
 699    {
 700       // Max error in interpolated form:             1.999e-34
 701       // Max error found at long double precision:   2.156186e-33
 702
 703       static const T P[13] = {
 704          BOOST_MATH_BIG_CONSTANT(T, 113, -4.0545627381873738086704293881227365),
 705          BOOST_MATH_BIG_CONSTANT(T, 113, -4.70088348734699134347906176097717782),
 706          BOOST_MATH_BIG_CONSTANT(T, 113, -2.36921550900925512951976617607678789),
 707          BOOST_MATH_BIG_CONSTANT(T, 113, -0.684322583796369508367726293719322866),
 708          BOOST_MATH_BIG_CONSTANT(T, 113, -0.126026534540165129870721937592996324),
 709          BOOST_MATH_BIG_CONSTANT(T, 113, -0.015636903921778316147260572008619549),
 710          BOOST_MATH_BIG_CONSTANT(T, 113, -0.00135442294754728549644376325814460807),
 711          BOOST_MATH_BIG_CONSTANT(T, 113, -0.842793965853572134365031384646117061e-4),
 712          BOOST_MATH_BIG_CONSTANT(T, 113, -0.385602133791111663372015460784978351e-5),
 713          BOOST_MATH_BIG_CONSTANT(T, 113, -0.130458500394692067189883214401478539e-6),
 714          BOOST_MATH_BIG_CONSTANT(T, 113, -0.315861074947230418778143153383660035e-8),
 715          BOOST_MATH_BIG_CONSTANT(T, 113, -0.500334720512030826996373077844707164e-10),
 716          BOOST_MATH_BIG_CONSTANT(T, 113, -0.420204769185233365849253969097184005e-12),
 717         };
 718       static const T Q[14] = {
 719          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 720          BOOST_MATH_BIG_CONSTANT(T, 113, 0.97663511666410096104783358493318814),
 721          BOOST_MATH_BIG_CONSTANT(T, 113, 0.40878780231201806504987368939673249),
 722          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0963890666609396058945084107597727252),
 723          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0142207619090854604824116070866614505),
 724          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00139010220902667918476773423995750877),
 725          BOOST_MATH_BIG_CONSTANT(T, 113, 0.940669540194694997889636696089994734e-4),
 726          BOOST_MATH_BIG_CONSTANT(T, 113, 0.458220848507517004399292480807026602e-5),
 727          BOOST_MATH_BIG_CONSTANT(T, 113, 0.16345521617741789012782420625435495e-6),
 728          BOOST_MATH_BIG_CONSTANT(T, 113, 0.414007452533083304371566316901024114e-8),
 729          BOOST_MATH_BIG_CONSTANT(T, 113, 0.68701473543366328016953742622661377e-10),
 730          BOOST_MATH_BIG_CONSTANT(T, 113, 0.603461891080716585087883971886075863e-12),
 731          BOOST_MATH_BIG_CONSTANT(T, 113, 0.294670713571839023181857795866134957e-16),
 732          BOOST_MATH_BIG_CONSTANT(T, 113, -0.147003914536437243143096875069813451e-18),
 733         };
 734       result = tools::evaluate_polynomial(P, T(s - 6)) / tools::evaluate_polynomial(Q, T(s - 6));
 735       result = 1 + exp(result);
 736    }
 737    else if(s < 17)
 738    {
 739       // Max error in interpolated form:             1.641e-32
 740       // Max error found at long double precision:   1.696121e-32
 741       static const T P[13] = {
 742          BOOST_MATH_BIG_CONSTANT(T, 113, -6.91319491921722925920883787894829678),
 743          BOOST_MATH_BIG_CONSTANT(T, 113, -3.65491257639481960248690596951049048),
 744          BOOST_MATH_BIG_CONSTANT(T, 113, -0.813557553449954526442644544105257881),
 745          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0994317301685870959473658713841138083),
 746          BOOST_MATH_BIG_CONSTANT(T, 113, -0.00726896610245676520248617014211734906),
 747          BOOST_MATH_BIG_CONSTANT(T, 113, -0.000317253318715075854811266230916762929),
 748          BOOST_MATH_BIG_CONSTANT(T, 113, -0.66851422826636750855184211580127133e-5),
 749          BOOST_MATH_BIG_CONSTANT(T, 113, 0.879464154730985406003332577806849971e-7),
 750          BOOST_MATH_BIG_CONSTANT(T, 113, 0.113838903158254250631678791998294628e-7),
 751          BOOST_MATH_BIG_CONSTANT(T, 113, 0.379184410304927316385211327537817583e-9),
 752          BOOST_MATH_BIG_CONSTANT(T, 113, 0.612992858643904887150527613446403867e-11),
 753          BOOST_MATH_BIG_CONSTANT(T, 113, 0.347873737198164757035457841688594788e-13),
 754          BOOST_MATH_BIG_CONSTANT(T, 113, -0.289187187441625868404494665572279364e-15),
 755         };
 756       static const T Q[14] = {
 757          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 758          BOOST_MATH_BIG_CONSTANT(T, 113, 0.427310044448071818775721584949868806),
 759          BOOST_MATH_BIG_CONSTANT(T, 113, 0.074602514873055756201435421385243062),
 760          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00688651562174480772901425121653945942),
 761          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000360174847635115036351323894321880445),
 762          BOOST_MATH_BIG_CONSTANT(T, 113, 0.973556847713307543918865405758248777e-5),
 763          BOOST_MATH_BIG_CONSTANT(T, 113, -0.853455848314516117964634714780874197e-8),
 764          BOOST_MATH_BIG_CONSTANT(T, 113, -0.118203513654855112421673192194622826e-7),
 765          BOOST_MATH_BIG_CONSTANT(T, 113, -0.462521662511754117095006543363328159e-9),
 766          BOOST_MATH_BIG_CONSTANT(T, 113, -0.834212591919475633107355719369463143e-11),
 767          BOOST_MATH_BIG_CONSTANT(T, 113, -0.5354594751002702935740220218582929e-13),
 768          BOOST_MATH_BIG_CONSTANT(T, 113, 0.406451690742991192964889603000756203e-15),
 769          BOOST_MATH_BIG_CONSTANT(T, 113, 0.887948682401000153828241615760146728e-19),
 770          BOOST_MATH_BIG_CONSTANT(T, 113, -0.34980761098820347103967203948619072e-21),
 771         };
 772       result = tools::evaluate_polynomial(P, T(s - 10)) / tools::evaluate_polynomial(Q, T(s - 10));
 773       result = 1 + exp(result);
 774    }
 775    else if(s < 30)
 776    {
 777       // Max error in interpolated form:             1.563e-31
 778       // Max error found at long double precision:   1.562725e-31
 779
 780       static const T P[13] = {
 781          BOOST_MATH_BIG_CONSTANT(T, 113, -11.7824798233959252791987402769438322),
 782          BOOST_MATH_BIG_CONSTANT(T, 113, -4.36131215284987731928174218354118102),
 783          BOOST_MATH_BIG_CONSTANT(T, 113, -0.732260980060982349410898496846972204),
 784          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0744985185694913074484248803015717388),
 785          BOOST_MATH_BIG_CONSTANT(T, 113, -0.00517228281320594683022294996292250527),
 786          BOOST_MATH_BIG_CONSTANT(T, 113, -0.000260897206152101522569969046299309939),
 787          BOOST_MATH_BIG_CONSTANT(T, 113, -0.989553462123121764865178453128769948e-5),
 788          BOOST_MATH_BIG_CONSTANT(T, 113, -0.286916799741891410827712096608826167e-6),
 789          BOOST_MATH_BIG_CONSTANT(T, 113, -0.637262477796046963617949532211619729e-8),
 790          BOOST_MATH_BIG_CONSTANT(T, 113, -0.106796831465628373325491288787760494e-9),
 791          BOOST_MATH_BIG_CONSTANT(T, 113, -0.129343095511091870860498356205376823e-11),
 792          BOOST_MATH_BIG_CONSTANT(T, 113, -0.102397936697965977221267881716672084e-13),
 793          BOOST_MATH_BIG_CONSTANT(T, 113, -0.402663128248642002351627980255756363e-16),
 794       };
 795       static const T Q[14] = {
 796          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 797          BOOST_MATH_BIG_CONSTANT(T, 113, 0.311288325355705609096155335186466508),
 798          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0438318468940415543546769437752132748),
 799          BOOST_MATH_BIG_CONSTANT(T, 113, 0.00374396349183199548610264222242269536),
 800          BOOST_MATH_BIG_CONSTANT(T, 113, 0.000218707451200585197339671707189281302),
 801          BOOST_MATH_BIG_CONSTANT(T, 113, 0.927578767487930747532953583797351219e-5),
 802          BOOST_MATH_BIG_CONSTANT(T, 113, 0.294145760625753561951137473484889639e-6),
 803          BOOST_MATH_BIG_CONSTANT(T, 113, 0.704618586690874460082739479535985395e-8),
 804          BOOST_MATH_BIG_CONSTANT(T, 113, 0.126333332872897336219649130062221257e-9),
 805          BOOST_MATH_BIG_CONSTANT(T, 113, 0.16317315713773503718315435769352765e-11),
 806          BOOST_MATH_BIG_CONSTANT(T, 113, 0.137846712823719515148344938160275695e-13),
 807          BOOST_MATH_BIG_CONSTANT(T, 113, 0.580975420554224366450994232723910583e-16),
 808          BOOST_MATH_BIG_CONSTANT(T, 113, -0.291354445847552426900293580511392459e-22),
 809          BOOST_MATH_BIG_CONSTANT(T, 113, 0.73614324724785855925025452085443636e-25),
 810       };
 811       result = tools::evaluate_polynomial(P, T(s - 17)) / tools::evaluate_polynomial(Q, T(s - 17));
 812       result = 1 + exp(result);
 813    }
 814    else if(s < 74)
 815    {
 816       // Max error in interpolated form:             2.311e-27
 817       // Max error found at long double precision:   2.297544e-27
 818       static const T P[14] = {
 819          BOOST_MATH_BIG_CONSTANT(T, 113, -20.7944102007844314586649688802236072),
 820          BOOST_MATH_BIG_CONSTANT(T, 113, -4.95759941987499442499908748130192187),
 821          BOOST_MATH_BIG_CONSTANT(T, 113, -0.563290752832461751889194629200298688),
 822          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0406197001137935911912457120706122877),
 823          BOOST_MATH_BIG_CONSTANT(T, 113, -0.0020846534789473022216888863613422293),
 824          BOOST_MATH_BIG_CONSTANT(T, 113, -0.808095978462109173749395599401375667e-4),
 825          BOOST_MATH_BIG_CONSTANT(T, 113, -0.244706022206249301640890603610060959e-5),
 826          BOOST_MATH_BIG_CONSTANT(T, 113, -0.589477682919645930544382616501666572e-7),
 827          BOOST_MATH_BIG_CONSTANT(T, 113, -0.113699573675553496343617442433027672e-8),
 828          BOOST_MATH_BIG_CONSTANT(T, 113, -0.174767860183598149649901223128011828e-10),
 829          BOOST_MATH_BIG_CONSTANT(T, 113, -0.210051620306761367764549971980026474e-12),
 830          BOOST_MATH_BIG_CONSTANT(T, 113, -0.189187969537370950337212675466400599e-14),
 831          BOOST_MATH_BIG_CONSTANT(T, 113, -0.116313253429564048145641663778121898e-16),
 832          BOOST_MATH_BIG_CONSTANT(T, 113, -0.376708747782400769427057630528578187e-19),
 833       };
 834       static const T Q[16] = {
 835          BOOST_MATH_BIG_CONSTANT(T, 113, 1.0),
 836          BOOST_MATH_BIG_CONSTANT(T, 113, 0.205076752981410805177554569784219717),
 837          BOOST_MATH_BIG_CONSTANT(T, 113, 0.0202526722696670378999575738524540269),
 838          BOOST_MATH_BIG_CONSTANT(T, 113, 0.001278305290005994980069466658219057),
 839          BOOST_MATH_BIG_CONSTANT(T, 113, 0.576404779858501791742255670403304787e-4),
 840          BOOST_MATH_BIG_CONSTANT(T, 113, 0.196477049872253010859712483984252067e-5),
 841          BOOST_MATH_BIG_CONSTANT(T, 113, 0.521863830500876189501054079974475762e-7),
 842          BOOST_MATH_BIG_CONSTANT(T, 113, 0.109524209196868135198775445228552059e-8),
 843          BOOST_MATH_BIG_CONSTANT(T, 113, 0.181698713448644481083966260949267825e-10),
 844          BOOST_MATH_BIG_CONSTANT(T, 113, 0.234793316975091282090312036524695562e-12),
 845          BOOST_MATH_BIG_CONSTANT(T, 113, 0.227490441461460571047545264251399048e-14),
 846          BOOST_MATH_BIG_CONSTANT(T, 113, 0.151500292036937400913870642638520668e-16),
 847          BOOST_MATH_BIG_CONSTANT(T, 113, 0.543475775154780935815530649335936121e-19),
 848          BOOST_MATH_BIG_CONSTANT(T, 113, 0.241647013434111434636554455083309352e-28),
 849          BOOST_MATH_BIG_CONSTANT(T, 113, -0.557103423021951053707162364713587374e-31),
 850          BOOST_MATH_BIG_CONSTANT(T, 113, 0.618708773442584843384712258199645166e-34),
 851       };
 852       result = tools::evaluate_polynomial(P, T(s - 30)) / tools::evaluate_polynomial(Q, T(s - 30));
 853       result = 1 + exp(result);
 854    }
 855    else if(s < 117)
 856    {
 857       result = 1 + pow(T(2), -s);
 858    }
 859    else
 860    {
 861       result = 1;
 862    }
 863    return result;
 864 }
 865
 866 template <class T, class Policy, class Tag>
 867 T zeta_imp(T s, T sc, const Policy& pol, const Tag& tag)
 868 {
 869    BOOST_MATH_STD_USING
 870    static const char* function = "boost::math::zeta<%1%>";
 871    if(sc == 0)
 872       return policies::raise_pole_error<T>(
 873          function,
 874          "Evaluation of zeta function at pole %1%",
 875          s, pol);
 876    T result;
 877    if(fabs(s) < tools::root_epsilon<T>())
 878    {
 879       result = -0.5f - constants::log_root_two_pi<T, Policy>() * s;
 880    }
 881    else if(s < 0)
 882    {
 883       std::swap(s, sc);
 884       if(floor(sc/2) == sc/2)
 885          result = 0;
 886       else
 887       {
 888          if(s > max_factorial<T>::value)
 889          {
 890             T mult = boost::math::sin_pi(0.5f * sc, pol) * 2 * zeta_imp(s, sc, pol, tag);
 891             result = boost::math::lgamma(s, pol);
 892             result -= s * log(2 * constants::pi<T>());
 893             if(result > tools::log_max_value<T>())
 894                return sign(mult) * policies::raise_overflow_error<T>(function, 0, pol);
 895             result = exp(result);
 896             if(tools::max_value<T>() / fabs(mult) < result)
 897                return boost::math::sign(mult) * policies::raise_overflow_error<T>(function, 0, pol);
 898             result *= mult;
 899          }
 900          else
 901          {
 902             result = boost::math::sin_pi(0.5f * sc, pol)
 903                * 2 * pow(2 * constants::pi<T>(), -s)
 904                * boost::math::tgamma(s, pol)
 905                * zeta_imp(s, sc, pol, tag);
 906          }
 907       }
 908    }
 909    else
 910    {
 911       result = zeta_imp_prec(s, sc, pol, tag);
 912    }
 913    return result;
 914 }
 915
 916 template <class T, class Policy, class tag>
 917 struct zeta_initializer
 918 {
 919    struct init
 920    {
 921       init()
 922       {
 923          do_init(tag());
 924       }
 925       static void do_init(const mpl::int_<0>&){}
 926       static void do_init(const mpl::int_<53>&){}
 927       static void do_init(const mpl::int_<64>&)
 928       {
 929          boost::math::zeta(static_cast<T>(0.5), Policy());
 930          boost::math::zeta(static_cast<T>(1.5), Policy());
 931          boost::math::zeta(static_cast<T>(3.5), Policy());
 932          boost::math::zeta(static_cast<T>(6.5), Policy());
 933          boost::math::zeta(static_cast<T>(14.5), Policy());
 934          boost::math::zeta(static_cast<T>(40.5), Policy());
 935       }
 936       static void do_init(const mpl::int_<113>&)
 937       {
 938          boost::math::zeta(static_cast<T>(0.5), Policy());
 939          boost::math::zeta(static_cast<T>(1.5), Policy());
 940          boost::math::zeta(static_cast<T>(3.5), Policy());
 941          boost::math::zeta(static_cast<T>(5.5), Policy());
 942          boost::math::zeta(static_cast<T>(9.5), Policy());
 943          boost::math::zeta(static_cast<T>(16.5), Policy());
 944          boost::math::zeta(static_cast<T>(25), Policy());
 945          boost::math::zeta(static_cast<T>(70), Policy());
 946       }
 947       void force_instantiate()const{}
 948    };
 949    static const init initializer;
 950    static void force_instantiate()
 951    {
 952       initializer.force_instantiate();
 953    }
 954 };
 955
 956 template <class T, class Policy, class tag>
 957 const typename zeta_initializer<T, Policy, tag>::init zeta_initializer<T, Policy, tag>::initializer;
 958
 959 } // detail
 960
 961 template <class T, class Policy>
 962 inline typename tools::promote_args<T>::type zeta(T s, const Policy&)
 963 {
 964    typedef typename tools::promote_args<T>::type result_type;
 965    typedef typename policies::evaluation<result_type, Policy>::type value_type;
 966    typedef typename policies::precision<result_type, Policy>::type precision_type;
 967    typedef typename policies::normalise<
 968       Policy,
 969       policies::promote_float<false>,
 970       policies::promote_double<false>,
 971       policies::discrete_quantile<>,
 972       policies::assert_undefined<> >::type forwarding_policy;
 973    typedef typename mpl::if_<
 974       mpl::less_equal<precision_type, mpl::int_<0> >,
 975       mpl::int_<0>,
 976       typename mpl::if_<
 977          mpl::less_equal<precision_type, mpl::int_<53> >,
 978          mpl::int_<53>,  // double
 979          typename mpl::if_<
 980             mpl::less_equal<precision_type, mpl::int_<64> >,
 981             mpl::int_<64>, // 80-bit long double
 982             typename mpl::if_<
 983                mpl::less_equal<precision_type, mpl::int_<113> >,
 984                mpl::int_<113>, // 128-bit long double
 985                mpl::int_<0> // too many bits, use generic version.
 986             >::type
 987          >::type
 988       >::type
 989    >::type tag_type;
 990    //typedef mpl::int_<0> tag_type;
 991
 992    detail::zeta_initializer<value_type, forwarding_policy, tag_type>::force_instantiate();
 993
 994    return policies::checked_narrowing_cast<result_type, forwarding_policy>(detail::zeta_imp(
 995       static_cast<value_type>(s),
 996       static_cast<value_type>(1 - static_cast<value_type>(s)),
 997       forwarding_policy(),
 998       tag_type()), "boost::math::zeta<%1%>(%1%)");
 999 }
1000
1001 template <class T>
1002 inline typename tools::promote_args<T>::type zeta(T s)
1003 {
1004    return zeta(s, policies::policy<>());
1005 }
1006
1007 }} // namespaces
1008
1009 #endif // BOOST_MATH_ZETA_HPP
1010
1011
1012