boost/math/special_functions/lanczos.hpp

   1 //  (C) Copyright John Maddock 2006.
   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_SPECIAL_FUNCTIONS_LANCZOS
   7 #define BOOST_MATH_SPECIAL_FUNCTIONS_LANCZOS
   8
   9 #ifdef _MSC_VER
  10 #pragma once
  11 #endif
  12
  13 #include <boost/config.hpp>
  14 #include <boost/math/tools/big_constant.hpp>
  15 #include <boost/mpl/if.hpp>
  16 #include <boost/limits.hpp>
  17 #include <boost/cstdint.hpp>
  18 #include <boost/math/tools/rational.hpp>
  19 #include <boost/math/policies/policy.hpp>
  20 #include <boost/mpl/less_equal.hpp>
  21
  22 #include <limits.h>
  23
  24 namespace boost{ namespace math{ namespace lanczos{
  25
  26 //
  27 // Individual lanczos approximations start here.
  28 //
  29 // Optimal values for G for each N are taken from
  30 // http://web.mala.bc.ca/pughg/phdThesis/phdThesis.pdf,
  31 // as are the theoretical error bounds.
  32 //
  33 // Constants calculated using the method described by Godfrey
  34 // http://my.fit.edu/~gabdo/gamma.txt and elaborated by Toth at
  35 // http://www.rskey.org/gamma.htm using NTL::RR at 1000 bit precision.
  36 //
  37 // Begin with a small helper to force initialization of constants prior
  38 // to main.  This makes the constant initialization thread safe, even
  39 // when called with a user-defined number type.
  40 //
  41 template <class Lanczos, class T>
  42 struct lanczos_initializer
  43 {
  44    struct init
  45    {
  46       init()
  47       {
  48          T t(1);
  49          Lanczos::lanczos_sum(t);
  50          Lanczos::lanczos_sum_expG_scaled(t);
  51          Lanczos::lanczos_sum_near_1(t);
  52          Lanczos::lanczos_sum_near_2(t);
  53          Lanczos::g();
  54       }
  55       void force_instantiate()const{}
  56    };
  57    static const init initializer;
  58    static void force_instantiate()
  59    {
  60       initializer.force_instantiate();
  61    }
  62 };
  63 template <class Lanczos, class T>
  64 typename lanczos_initializer<Lanczos, T>::init const lanczos_initializer<Lanczos, T>::initializer;
  65 //
  66 // Lanczos Coefficients for N=6 G=5.581
  67 // Max experimental error (with arbitary precision arithmetic) 9.516e-12
  68 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
  69 //
  70 struct lanczos6 : public mpl::int_<35>
  71 {
  72    //
  73    // Produces slightly better than float precision when evaluated at
  74    // double precision:
  75    //
  76    template <class T>
  77    static T lanczos_sum(const T& z)
  78    {
  79       lanczos_initializer<lanczos6, T>::force_instantiate(); // Ensure our constants get initialized before main()
  80       static const T num[6] = {
  81          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 8706.349592549009182288174442774377925882)),
  82          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 8523.650341121874633477483696775067709735)),
  83          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 3338.029219476423550899999750161289306564)),
  84          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 653.6424994294008795995653541449610986791)),
  85          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 63.99951844938187085666201263218840287667)),
  86          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 2.506628274631006311133031631822390264407))
  87       };
  88       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint16_t) denom[6] = {
  89          static_cast<boost::uint16_t>(0u),
  90          static_cast<boost::uint16_t>(24u),
  91          static_cast<boost::uint16_t>(50u),
  92          static_cast<boost::uint16_t>(35u),
  93          static_cast<boost::uint16_t>(10u),
  94          static_cast<boost::uint16_t>(1u)
  95       };
  96       return boost::math::tools::evaluate_rational(num, denom, z);
  97    }
  98
  99    template <class T>
 100    static T lanczos_sum_expG_scaled(const T& z)
 101    {
 102       lanczos_initializer<lanczos6, T>::force_instantiate(); // Ensure our constants get initialized before main()
 103       static const T num[6] = {
 104          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 32.81244541029783471623665933780748627823)),
 105          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 32.12388941444332003446077108933558534361)),
 106          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 12.58034729455216106950851080138931470954)),
 107          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 2.463444478353241423633780693218408889251)),
 108          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 0.2412010548258800231126240760264822486599)),
 109          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 0.009446967704539249494420221613134244048319))
 110       };
 111       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint16_t) denom[6] = {
 112          static_cast<boost::uint16_t>(0u),
 113          static_cast<boost::uint16_t>(24u),
 114          static_cast<boost::uint16_t>(50u),
 115          static_cast<boost::uint16_t>(35u),
 116          static_cast<boost::uint16_t>(10u),
 117          static_cast<boost::uint16_t>(1u)
 118       };
 119       return boost::math::tools::evaluate_rational(num, denom, z);
 120    }
 121
 122
 123    template<class T>
 124    static T lanczos_sum_near_1(const T& dz)
 125    {
 126       lanczos_initializer<lanczos6, T>::force_instantiate(); // Ensure our constants get initialized before main()
 127       static const T d[5] = {
 128          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 2.044879010930422922760429926121241330235)),
 129          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, -2.751366405578505366591317846728753993668)),
 130          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 1.02282965224225004296750609604264824677)),
 131          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, -0.09786124911582813985028889636665335893627)),
 132          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 0.0009829742267506615183144364420540766510112)),
 133       };
 134       T result = 0;
 135       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 136       {
 137          result += (-d[k-1]*dz)/(k*dz + k*k);
 138       }
 139       return result;
 140    }
 141
 142    template<class T>
 143    static T lanczos_sum_near_2(const T& dz)
 144    {
 145       lanczos_initializer<lanczos6, T>::force_instantiate(); // Ensure our constants get initialized before main()
 146       static const T d[5] = {
 147          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 5.748142489536043490764289256167080091892)),
 148          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, -7.734074268282457156081021756682138251825)),
 149          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 2.875167944990511006997713242805893543947)),
 150          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, -0.2750873773533504542306766137703788781776)),
 151          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 35, 0.002763134585812698552178368447708846850353)),
 152       };
 153       T result = 0;
 154       T z = dz + 2;
 155       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 156       {
 157          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
 158       }
 159       return result;
 160    }
 161
 162    static double g(){ return 5.581000000000000405009359383257105946541; }
 163 };
 164
 165 //
 166 // Lanczos Coefficients for N=11 G=10.900511
 167 // Max experimental error (with arbitary precision arithmetic) 2.16676e-19
 168 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
 169 //
 170 struct lanczos11 : public mpl::int_<60>
 171 {
 172    //
 173    // Produces slightly better than double precision when evaluated at
 174    // extended-double precision:
 175    //
 176    template <class T>
 177    static T lanczos_sum(const T& z)
 178    {
 179       lanczos_initializer<lanczos11, T>::force_instantiate(); // Ensure our constants get initialized before main()
 180       static const T num[11] = {
 181          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 38474670393.31776828316099004518914832218)),
 182          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 36857665043.51950660081971227404959150474)),
 183          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 15889202453.72942008945006665994637853242)),
 184          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 4059208354.298834770194507810788393801607)),
 185          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 680547661.1834733286087695557084801366446)),
 186          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 78239755.00312005289816041245285376206263)),
 187          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 6246580.776401795264013335510453568106366)),
 188          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 341986.3488721347032223777872763188768288)),
 189          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 12287.19451182455120096222044424100527629)),
 190          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 261.6140441641668190791708576058805625502)),
 191          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 2.506628274631000502415573855452633787834))
 192       };
 193       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint32_t) denom[11] = {
 194          static_cast<boost::uint32_t>(0u),
 195          static_cast<boost::uint32_t>(362880u),
 196          static_cast<boost::uint32_t>(1026576u),
 197          static_cast<boost::uint32_t>(1172700u),
 198          static_cast<boost::uint32_t>(723680u),
 199          static_cast<boost::uint32_t>(269325u),
 200          static_cast<boost::uint32_t>(63273u),
 201          static_cast<boost::uint32_t>(9450u),
 202          static_cast<boost::uint32_t>(870u),
 203          static_cast<boost::uint32_t>(45u),
 204          static_cast<boost::uint32_t>(1u)
 205       };
 206       return boost::math::tools::evaluate_rational(num, denom, z);
 207    }
 208
 209    template <class T>
 210    static T lanczos_sum_expG_scaled(const T& z)
 211    {
 212       lanczos_initializer<lanczos11, T>::force_instantiate(); // Ensure our constants get initialized before main()
 213       static const T num[11] = {
 214          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 709811.662581657956893540610814842699825)),
 215          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 679979.847415722640161734319823103390728)),
 216          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 293136.785721159725251629480984140341656)),
 217          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 74887.5403291467179935942448101441897121)),
 218          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 12555.29058241386295096255111537516768137)),
 219          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 1443.42992444170669746078056942194198252)),
 220          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 115.2419459613734722083208906727972935065)),
 221          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 6.30923920573262762719523981992008976989)),
 222          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.2266840463022436475495508977579735223818)),
 223          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.004826466289237661857584712046231435101741)),
 224          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.4624429436045378766270459638520555557321e-4))
 225       };
 226       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint32_t) denom[11] = {
 227          static_cast<boost::uint32_t>(0u),
 228          static_cast<boost::uint32_t>(362880u),
 229          static_cast<boost::uint32_t>(1026576u),
 230          static_cast<boost::uint32_t>(1172700u),
 231          static_cast<boost::uint32_t>(723680u),
 232          static_cast<boost::uint32_t>(269325u),
 233          static_cast<boost::uint32_t>(63273u),
 234          static_cast<boost::uint32_t>(9450u),
 235          static_cast<boost::uint32_t>(870u),
 236          static_cast<boost::uint32_t>(45u),
 237          static_cast<boost::uint32_t>(1u)
 238       };
 239       return boost::math::tools::evaluate_rational(num, denom, z);
 240    }
 241
 242
 243    template<class T>
 244    static T lanczos_sum_near_1(const T& dz)
 245    {
 246       lanczos_initializer<lanczos11, T>::force_instantiate(); // Ensure our constants get initialized before main()
 247       static const T d[10] = {
 248          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 4.005853070677940377969080796551266387954)),
 249          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -13.17044315127646469834125159673527183164)),
 250          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 17.19146865350790353683895137079288129318)),
 251          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -11.36446409067666626185701599196274701126)),
 252          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 4.024801119349323770107694133829772634737)),
 253          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -0.7445703262078094128346501724255463005006)),
 254          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.06513861351917497265045550019547857713172)),
 255          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -0.00217899958561830354633560009312512312758)),
 256          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.17655204574495137651670832229571934738e-4)),
 257          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -0.1036282091079938047775645941885460820853e-7)),
 258       };
 259       T result = 0;
 260       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 261       {
 262          result += (-d[k-1]*dz)/(k*dz + k*k);
 263       }
 264       return result;
 265    }
 266
 267    template<class T>
 268    static T lanczos_sum_near_2(const T& dz)
 269    {
 270       lanczos_initializer<lanczos11, T>::force_instantiate(); // Ensure our constants get initialized before main()
 271       static const T d[10] = {
 272          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 19.05889633808148715159575716844556056056)),
 273          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -62.66183664701721716960978577959655644762)),
 274          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 81.7929198065004751699057192860287512027)),
 275          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -54.06941772964234828416072865069196553015)),
 276          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 19.14904664790693019642068229478769661515)),
 277          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -3.542488556926667589704590409095331790317)),
 278          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.3099140334815639910894627700232804503017)),
 279          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -0.01036716187296241640634252431913030440825)),
 280          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, 0.8399926504443119927673843789048514017761e-4)),
 281          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 60, -0.493038376656195010308610694048822561263e-7)),
 282       };
 283       T result = 0;
 284       T z = dz + 2;
 285       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 286       {
 287          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
 288       }
 289       return result;
 290    }
 291
 292    static double g(){ return 10.90051099999999983936049829935654997826; }
 293 };
 294
 295 //
 296 // Lanczos Coefficients for N=13 G=13.144565
 297 // Max experimental error (with arbitary precision arithmetic) 9.2213e-23
 298 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
 299 //
 300 struct lanczos13 : public mpl::int_<72>
 301 {
 302    //
 303    // Produces slightly better than extended-double precision when evaluated at
 304    // higher precision:
 305    //
 306    template <class T>
 307    static T lanczos_sum(const T& z)
 308    {
 309       lanczos_initializer<lanczos13, T>::force_instantiate(); // Ensure our constants get initialized before main()
 310       static const T num[13] = {
 311          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 44012138428004.60895436261759919070125699)),
 312          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 41590453358593.20051581730723108131357995)),
 313          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 18013842787117.99677796276038389462742949)),
 314          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 4728736263475.388896889723995205703970787)),
 315          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 837910083628.4046470415724300225777912264)),
 316          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 105583707273.4299344907359855510105321192)),
 317          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 9701363618.494999493386608345339104922694)),
 318          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 654914397.5482052641016767125048538245644)),
 319          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 32238322.94213356530668889463945849409184)),
 320          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 1128514.219497091438040721811544858643121)),
 321          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 26665.79378459858944762533958798805525125)),
 322          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 381.8801248632926870394389468349331394196)),
 323          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 2.506628274631000502415763426076722427007))
 324       };
 325       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint32_t) denom[13] = {
 326          static_cast<boost::uint32_t>(0u),
 327          static_cast<boost::uint32_t>(39916800u),
 328          static_cast<boost::uint32_t>(120543840u),
 329          static_cast<boost::uint32_t>(150917976u),
 330          static_cast<boost::uint32_t>(105258076u),
 331          static_cast<boost::uint32_t>(45995730u),
 332          static_cast<boost::uint32_t>(13339535u),
 333          static_cast<boost::uint32_t>(2637558u),
 334          static_cast<boost::uint32_t>(357423u),
 335          static_cast<boost::uint32_t>(32670u),
 336          static_cast<boost::uint32_t>(1925u),
 337          static_cast<boost::uint32_t>(66u),
 338          static_cast<boost::uint32_t>(1u)
 339       };
 340       return boost::math::tools::evaluate_rational(num, denom, z);
 341    }
 342
 343    template <class T>
 344    static T lanczos_sum_expG_scaled(const T& z)
 345    {
 346       lanczos_initializer<lanczos13, T>::force_instantiate(); // Ensure our constants get initialized before main()
 347       static const T num[13] = {
 348          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 86091529.53418537217994842267760536134841)),
 349          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 81354505.17858011242874285785316135398567)),
 350          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 35236626.38815461910817650960734605416521)),
 351          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 9249814.988024471294683815872977672237195)),
 352          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 1639024.216687146960253839656643518985826)),
 353          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 206530.8157641225032631778026076868855623)),
 354          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 18976.70193530288915698282139308582105936)),
 355          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 1281.068909912559479885759622791374106059)),
 356          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 63.06093343420234536146194868906771599354)),
 357          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 2.207470909792527638222674678171050209691)),
 358          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.05216058694613505427476207805814960742102)),
 359          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.0007469903808915448316510079585999893674101)),
 360          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.4903180573459871862552197089738373164184e-5))
 361       };
 362       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint32_t) denom[13] = {
 363          static_cast<boost::uint32_t>(0u),
 364          static_cast<boost::uint32_t>(39916800u),
 365          static_cast<boost::uint32_t>(120543840u),
 366          static_cast<boost::uint32_t>(150917976u),
 367          static_cast<boost::uint32_t>(105258076u),
 368          static_cast<boost::uint32_t>(45995730u),
 369          static_cast<boost::uint32_t>(13339535u),
 370          static_cast<boost::uint32_t>(2637558u),
 371          static_cast<boost::uint32_t>(357423u),
 372          static_cast<boost::uint32_t>(32670u),
 373          static_cast<boost::uint32_t>(1925u),
 374          static_cast<boost::uint32_t>(66u),
 375          static_cast<boost::uint32_t>(1u)
 376       };
 377       return boost::math::tools::evaluate_rational(num, denom, z);
 378    }
 379
 380
 381    template<class T>
 382    static T lanczos_sum_near_1(const T& dz)
 383    {
 384       lanczos_initializer<lanczos13, T>::force_instantiate(); // Ensure our constants get initialized before main()
 385       static const T d[12] = {
 386          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 4.832115561461656947793029596285626840312)),
 387          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -19.86441536140337740383120735104359034688)),
 388          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 33.9927422807443239927197864963170585331)),
 389          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -31.41520692249765980987427413991250886138)),
 390          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 17.0270866009599345679868972409543597821)),
 391          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -5.5077216950865501362506920516723682167)),
 392          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 1.037811741948214855286817963800439373362)),
 393          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -0.106640468537356182313660880481398642811)),
 394          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.005276450526660653288757565778182586742831)),
 395          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -0.0001000935625597121545867453746252064770029)),
 396          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.462590910138598083940803704521211569234e-6)),
 397          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -0.1735307814426389420248044907765671743012e-9)),
 398       };
 399       T result = 0;
 400       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 401       {
 402          result += (-d[k-1]*dz)/(k*dz + k*k);
 403       }
 404       return result;
 405    }
 406
 407    template<class T>
 408    static T lanczos_sum_near_2(const T& dz)
 409    {
 410       lanczos_initializer<lanczos13, T>::force_instantiate(); // Ensure our constants get initialized before main()
 411       static const T d[12] = {
 412          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 26.96979819614830698367887026728396466395)),
 413          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -110.8705424709385114023884328797900204863)),
 414          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 189.7258846119231466417015694690434770085)),
 415          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -175.3397202971107486383321670769397356553)),
 416          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 95.03437648691551457087250340903980824948)),
 417          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -30.7406022781665264273675797983497141978)),
 418          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 5.792405601630517993355102578874590410552)),
 419          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -0.5951993240669148697377539518639997795831)),
 420          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.02944979359164017509944724739946255067671)),
 421          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -0.0005586586555377030921194246330399163602684)),
 422          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, 0.2581888478270733025288922038673392636029e-5)),
 423          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 72, -0.9685385411006641478305219367315965391289e-9)),
 424       };
 425       T result = 0;
 426       T z = dz + 2;
 427       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 428       {
 429          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
 430       }
 431       return result;
 432    }
 433
 434    static double g(){ return 13.1445650000000000545696821063756942749; }
 435 };
 436
 437 //
 438 // Lanczos Coefficients for N=22 G=22.61891
 439 // Max experimental error (with arbitary precision arithmetic) 2.9524e-38
 440 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
 441 //
 442 struct lanczos22 : public mpl::int_<120>
 443 {
 444    //
 445    // Produces slightly better than 128-bit long-double precision when
 446    // evaluated at higher precision:
 447    //
 448    template <class T>
 449    static T lanczos_sum(const T& z)
 450    {
 451       lanczos_initializer<lanczos22, T>::force_instantiate(); // Ensure our constants get initialized before main()
 452       static const T num[22] = {
 453          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 46198410803245094237463011094.12173081986)),
 454          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 43735859291852324413622037436.321513777)),
 455          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 19716607234435171720534556386.97481377748)),
 456          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 5629401471315018442177955161.245623932129)),
 457          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 1142024910634417138386281569.245580222392)),
 458          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 175048529315951173131586747.695329230778)),
 459          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 21044290245653709191654675.41581372963167)),
 460          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 2033001410561031998451380.335553678782601)),
 461          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 160394318862140953773928.8736211601848891)),
 462          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 10444944438396359705707.48957290388740896)),
 463          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 565075825801617290121.1466393747967538948)),
 464          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 25475874292116227538.99448534450411942597)),
 465          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 957135055846602154.6720835535232270205725)),
 466          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 29874506304047462.23662392445173880821515)),
 467          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 769651310384737.2749087590725764959689181)),
 468          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 16193289100889.15989633624378404096011797)),
 469          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 273781151680.6807433264462376754578933261)),
 470          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 3630485900.32917021712188739762161583295)),
 471          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 36374352.05577334277856865691538582936484)),
 472          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 258945.7742115532455441786924971194951043)),
 473          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 1167.501919472435718934219997431551246996)),
 474          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 2.50662827463100050241576528481104525333))
 475       };
 476       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint64_t) denom[22] = {
 477          BOOST_MATH_INT_VALUE_SUFFIX(0, uLL),
 478          BOOST_MATH_INT_VALUE_SUFFIX(2432902008176640000, uLL),
 479          BOOST_MATH_INT_VALUE_SUFFIX(8752948036761600000, uLL),
 480          BOOST_MATH_INT_VALUE_SUFFIX(13803759753640704000, uLL),
 481          BOOST_MATH_INT_VALUE_SUFFIX(12870931245150988800, uLL),
 482          BOOST_MATH_INT_VALUE_SUFFIX(8037811822645051776, uLL),
 483          BOOST_MATH_INT_VALUE_SUFFIX(3599979517947607200, uLL),
 484          BOOST_MATH_INT_VALUE_SUFFIX(1206647803780373360, uLL),
 485          BOOST_MATH_INT_VALUE_SUFFIX(311333643161390640, uLL),
 486          BOOST_MATH_INT_VALUE_SUFFIX(63030812099294896, uLL),
 487          BOOST_MATH_INT_VALUE_SUFFIX(10142299865511450, uLL),
 488          BOOST_MATH_INT_VALUE_SUFFIX(1307535010540395, uLL),
 489          BOOST_MATH_INT_VALUE_SUFFIX(135585182899530, uLL),
 490          BOOST_MATH_INT_VALUE_SUFFIX(11310276995381, uLL),
 491          BOOST_MATH_INT_VALUE_SUFFIX(756111184500, uLL),
 492          BOOST_MATH_INT_VALUE_SUFFIX(40171771630, uLL),
 493          BOOST_MATH_INT_VALUE_SUFFIX(1672280820, uLL),
 494          BOOST_MATH_INT_VALUE_SUFFIX(53327946, uLL),
 495          BOOST_MATH_INT_VALUE_SUFFIX(1256850, uLL),
 496          BOOST_MATH_INT_VALUE_SUFFIX(20615, uLL),
 497          BOOST_MATH_INT_VALUE_SUFFIX(210, uLL),
 498          BOOST_MATH_INT_VALUE_SUFFIX(1, uLL)
 499       };
 500       return boost::math::tools::evaluate_rational(num, denom, z);
 501    }
 502
 503    template <class T>
 504    static T lanczos_sum_expG_scaled(const T& z)
 505    {
 506       lanczos_initializer<lanczos22, T>::force_instantiate(); // Ensure our constants get initialized before main()
 507       static const T num[22] = {
 508          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 6939996264376682180.277485395074954356211)),
 509          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 6570067992110214451.87201438870245659384)),
 510          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 2961859037444440551.986724631496417064121)),
 511          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 845657339772791245.3541226499766163431651)),
 512          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 171556737035449095.2475716923888737881837)),
 513          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 26296059072490867.7822441885603400926007)),
 514          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 3161305619652108.433798300149816829198706)),
 515          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 305400596026022.4774396904484542582526472)),
 516          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 24094681058862.55120507202622377623528108)),
 517          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 1569055604375.919477574824168939428328839)),
 518          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 84886558909.02047889339710230696942513159)),
 519          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 3827024985.166751989686050643579753162298)),
 520          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 143782298.9273215199098728674282885500522)),
 521          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 4487794.24541641841336786238909171265944)),
 522          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 115618.2025760830513505888216285273541959)),
 523          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 2432.580773108508276957461757328744780439)),
 524          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 41.12782532742893597168530008461874360191)),
 525          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.5453771709477689805460179187388702295792)),
 526          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.005464211062612080347167337964166505282809)),
 527          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.388992321263586767037090706042788910953e-4)),
 528          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.1753839324538447655939518484052327068859e-6)),
 529          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.3765495513732730583386223384116545391759e-9))
 530       };
 531       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint64_t) denom[22] = {
 532          BOOST_MATH_INT_VALUE_SUFFIX(0, uLL),
 533          BOOST_MATH_INT_VALUE_SUFFIX(2432902008176640000, uLL),
 534          BOOST_MATH_INT_VALUE_SUFFIX(8752948036761600000, uLL),
 535          BOOST_MATH_INT_VALUE_SUFFIX(13803759753640704000, uLL),
 536          BOOST_MATH_INT_VALUE_SUFFIX(12870931245150988800, uLL),
 537          BOOST_MATH_INT_VALUE_SUFFIX(8037811822645051776, uLL),
 538          BOOST_MATH_INT_VALUE_SUFFIX(3599979517947607200, uLL),
 539          BOOST_MATH_INT_VALUE_SUFFIX(1206647803780373360, uLL),
 540          BOOST_MATH_INT_VALUE_SUFFIX(311333643161390640, uLL),
 541          BOOST_MATH_INT_VALUE_SUFFIX(63030812099294896, uLL),
 542          BOOST_MATH_INT_VALUE_SUFFIX(10142299865511450, uLL),
 543          BOOST_MATH_INT_VALUE_SUFFIX(1307535010540395, uLL),
 544          BOOST_MATH_INT_VALUE_SUFFIX(135585182899530, uLL),
 545          BOOST_MATH_INT_VALUE_SUFFIX(11310276995381, uLL),
 546          BOOST_MATH_INT_VALUE_SUFFIX(756111184500, uLL),
 547          BOOST_MATH_INT_VALUE_SUFFIX(40171771630, uLL),
 548          BOOST_MATH_INT_VALUE_SUFFIX(1672280820, uLL),
 549          BOOST_MATH_INT_VALUE_SUFFIX(53327946, uLL),
 550          BOOST_MATH_INT_VALUE_SUFFIX(1256850, uLL),
 551          BOOST_MATH_INT_VALUE_SUFFIX(20615, uLL),
 552          BOOST_MATH_INT_VALUE_SUFFIX(210, uLL),
 553          BOOST_MATH_INT_VALUE_SUFFIX(1, uLL)
 554       };
 555       return boost::math::tools::evaluate_rational(num, denom, z);
 556    }
 557
 558
 559    template<class T>
 560    static T lanczos_sum_near_1(const T& dz)
 561    {
 562       lanczos_initializer<lanczos22, T>::force_instantiate(); // Ensure our constants get initialized before main()
 563       static const T d[21] = {
 564          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 8.318998691953337183034781139546384476554)),
 565          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -63.15415991415959158214140353299240638675)),
 566          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 217.3108224383632868591462242669081540163)),
 567          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -448.5134281386108366899784093610397354889)),
 568          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 619.2903759363285456927248474593012711346)),
 569          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -604.1630177420625418522025080080444177046)),
 570          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 428.8166750424646119935047118287362193314)),
 571          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -224.6988753721310913866347429589434550302)),
 572          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 87.32181627555510833499451817622786940961)),
 573          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -25.07866854821128965662498003029199058098)),
 574          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 5.264398125689025351448861011657789005392)),
 575          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.792518936256495243383586076579921559914)),
 576          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.08317448364744713773350272460937904691566)),
 577          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.005845345166274053157781068150827567998882)),
 578          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.0002599412126352082483326238522490030412391)),
 579          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.6748102079670763884917431338234783496303e-5)),
 580          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.908824383434109002762325095643458603605e-7)),
 581          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.5299325929309389890892469299969669579725e-9)),
 582          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.994306085859549890267983602248532869362e-12)),
 583          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.3499893692975262747371544905820891835298e-15)),
 584          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.7260746353663365145454867069182884694961e-20)),
 585       };
 586       T result = 0;
 587       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 588       {
 589          result += (-d[k-1]*dz)/(k*dz + k*k);
 590       }
 591       return result;
 592    }
 593
 594    template<class T>
 595    static T lanczos_sum_near_2(const T& dz)
 596    {
 597       lanczos_initializer<lanczos22, T>::force_instantiate(); // Ensure our constants get initialized before main()
 598       static const T d[21] = {
 599          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 75.39272007105208086018421070699575462226)),
 600          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -572.3481967049935412452681346759966390319)),
 601          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 1969.426202741555335078065370698955484358)),
 602          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -4064.74968778032030891520063865996757519)),
 603          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 5612.452614138013929794736248384309574814)),
 604          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -5475.357667500026172903620177988213902339)),
 605          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 3886.243614216111328329547926490398103492)),
 606          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -2036.382026072125407192448069428134470564)),
 607          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 791.3727954936062108045551843636692287652)),
 608          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -227.2808432388436552794021219198885223122)),
 609          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 47.70974355562144229897637024320739257284)),
 610          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -7.182373807798293545187073539819697141572)),
 611          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.7537866989631514559601547530490976100468)),
 612          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.05297470142240154822658739758236594717787)),
 613          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.00235577330936380542539812701472320434133)),
 614          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.6115613067659273118098229498679502138802e-4)),
 615          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.8236417010170941915758315020695551724181e-6)),
 616          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.4802628430993048190311242611330072198089e-8)),
 617          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.9011113376981524418952720279739624707342e-11)),
 618          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, -0.3171854152689711198382455703658589996796e-14)),
 619          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 120, 0.6580207998808093935798753964580596673177e-19)),
 620       };
 621       T result = 0;
 622       T z = dz + 2;
 623       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 624       {
 625          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
 626       }
 627       return result;
 628    }
 629
 630    static double g(){ return 22.61890999999999962710717227309942245483; }
 631 };
 632
 633 //
 634 // Lanczos Coefficients for N=6 G=1.428456135094165802001953125
 635 // Max experimental error (with arbitary precision arithmetic) 8.111667e-8
 636 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
 637 //
 638 struct lanczos6m24 : public mpl::int_<24>
 639 {
 640    //
 641    // Use for float precision, when evaluated as a float:
 642    //
 643    template <class T>
 644    static T lanczos_sum(const T& z)
 645    {
 646       static const T num[6] = {
 647          static_cast<T>(58.52061591769095910314047740215847630266L),
 648          static_cast<T>(182.5248962595894264831189414768236280862L),
 649          static_cast<T>(211.0971093028510041839168287718170827259L),
 650          static_cast<T>(112.2526547883668146736465390902227161763L),
 651          static_cast<T>(27.5192015197455403062503721613097825345L),
 652          static_cast<T>(2.50662858515256974113978724717473206342L)
 653       };
 654       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint16_t) denom[6] = {
 655          static_cast<boost::uint16_t>(0u),
 656          static_cast<boost::uint16_t>(24u),
 657          static_cast<boost::uint16_t>(50u),
 658          static_cast<boost::uint16_t>(35u),
 659          static_cast<boost::uint16_t>(10u),
 660          static_cast<boost::uint16_t>(1u)
 661       };
 662       return boost::math::tools::evaluate_rational(num, denom, z);
 663    }
 664
 665    template <class T>
 666    static T lanczos_sum_expG_scaled(const T& z)
 667    {
 668       static const T num[6] = {
 669          static_cast<T>(14.0261432874996476619570577285003839357L),
 670          static_cast<T>(43.74732405540314316089531289293124360129L),
 671          static_cast<T>(50.59547402616588964511581430025589038612L),
 672          static_cast<T>(26.90456680562548195593733429204228910299L),
 673          static_cast<T>(6.595765571169314946316366571954421695196L),
 674          static_cast<T>(0.6007854010515290065101128585795542383721L)
 675       };
 676       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint16_t) denom[6] = {
 677          static_cast<boost::uint16_t>(0u),
 678          static_cast<boost::uint16_t>(24u),
 679          static_cast<boost::uint16_t>(50u),
 680          static_cast<boost::uint16_t>(35u),
 681          static_cast<boost::uint16_t>(10u),
 682          static_cast<boost::uint16_t>(1u)
 683       };
 684       return boost::math::tools::evaluate_rational(num, denom, z);
 685    }
 686
 687
 688    template<class T>
 689    static T lanczos_sum_near_1(const T& dz)
 690    {
 691       static const T d[5] = {
 692          static_cast<T>(0.4922488055204602807654354732674868442106L),
 693          static_cast<T>(0.004954497451132152436631238060933905650346L),
 694          static_cast<T>(-0.003374784572167105840686977985330859371848L),
 695          static_cast<T>(0.001924276018962061937026396537786414831385L),
 696          static_cast<T>(-0.00056533046336427583708166383712907694434L),
 697       };
 698       T result = 0;
 699       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 700       {
 701          result += (-d[k-1]*dz)/(k*dz + k*k);
 702       }
 703       return result;
 704    }
 705
 706    template<class T>
 707    static T lanczos_sum_near_2(const T& dz)
 708    {
 709       static const T d[5] = {
 710          static_cast<T>(0.6534966888520080645505805298901130485464L),
 711          static_cast<T>(0.006577461728560758362509168026049182707101L),
 712          static_cast<T>(-0.004480276069269967207178373559014835978161L),
 713          static_cast<T>(0.00255461870648818292376982818026706528842L),
 714          static_cast<T>(-0.000750517993690428370380996157470900204524L),
 715       };
 716       T result = 0;
 717       T z = dz + 2;
 718       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 719       {
 720          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
 721       }
 722       return result;
 723    }
 724
 725    static double g(){ return 1.428456135094165802001953125; }
 726 };
 727
 728 //
 729 // Lanczos Coefficients for N=13 G=6.024680040776729583740234375
 730 // Max experimental error (with arbitary precision arithmetic) 1.196214e-17
 731 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
 732 //
 733 struct lanczos13m53 : public mpl::int_<53>
 734 {
 735    //
 736    // Use for double precision, when evaluated as a double:
 737    //
 738    template <class T>
 739    static T lanczos_sum(const T& z)
 740    {
 741       static const T num[13] = {
 742          static_cast<T>(23531376880.41075968857200767445163675473L),
 743          static_cast<T>(42919803642.64909876895789904700198885093L),
 744          static_cast<T>(35711959237.35566804944018545154716670596L),
 745          static_cast<T>(17921034426.03720969991975575445893111267L),
 746          static_cast<T>(6039542586.35202800506429164430729792107L),
 747          static_cast<T>(1439720407.311721673663223072794912393972L),
 748          static_cast<T>(248874557.8620541565114603864132294232163L),
 749          static_cast<T>(31426415.58540019438061423162831820536287L),
 750          static_cast<T>(2876370.628935372441225409051620849613599L),
 751          static_cast<T>(186056.2653952234950402949897160456992822L),
 752          static_cast<T>(8071.672002365816210638002902272250613822L),
 753          static_cast<T>(210.8242777515793458725097339207133627117L),
 754          static_cast<T>(2.506628274631000270164908177133837338626L)
 755       };
 756       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint32_t) denom[13] = {
 757          static_cast<boost::uint32_t>(0u),
 758          static_cast<boost::uint32_t>(39916800u),
 759          static_cast<boost::uint32_t>(120543840u),
 760          static_cast<boost::uint32_t>(150917976u),
 761          static_cast<boost::uint32_t>(105258076u),
 762          static_cast<boost::uint32_t>(45995730u),
 763          static_cast<boost::uint32_t>(13339535u),
 764          static_cast<boost::uint32_t>(2637558u),
 765          static_cast<boost::uint32_t>(357423u),
 766          static_cast<boost::uint32_t>(32670u),
 767          static_cast<boost::uint32_t>(1925u),
 768          static_cast<boost::uint32_t>(66u),
 769          static_cast<boost::uint32_t>(1u)
 770       };
 771       return boost::math::tools::evaluate_rational(num, denom, z);
 772    }
 773
 774    template <class T>
 775    static T lanczos_sum_expG_scaled(const T& z)
 776    {
 777       static const T num[13] = {
 778          static_cast<T>(56906521.91347156388090791033559122686859L),
 779          static_cast<T>(103794043.1163445451906271053616070238554L),
 780          static_cast<T>(86363131.28813859145546927288977868422342L),
 781          static_cast<T>(43338889.32467613834773723740590533316085L),
 782          static_cast<T>(14605578.08768506808414169982791359218571L),
 783          static_cast<T>(3481712.15498064590882071018964774556468L),
 784          static_cast<T>(601859.6171681098786670226533699352302507L),
 785          static_cast<T>(75999.29304014542649875303443598909137092L),
 786          static_cast<T>(6955.999602515376140356310115515198987526L),
 787          static_cast<T>(449.9445569063168119446858607650988409623L),
 788          static_cast<T>(19.51992788247617482847860966235652136208L),
 789          static_cast<T>(0.5098416655656676188125178644804694509993L),
 790          static_cast<T>(0.006061842346248906525783753964555936883222L)
 791       };
 792       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint32_t) denom[13] = {
 793          static_cast<boost::uint32_t>(0u),
 794          static_cast<boost::uint32_t>(39916800u),
 795          static_cast<boost::uint32_t>(120543840u),
 796          static_cast<boost::uint32_t>(150917976u),
 797          static_cast<boost::uint32_t>(105258076u),
 798          static_cast<boost::uint32_t>(45995730u),
 799          static_cast<boost::uint32_t>(13339535u),
 800          static_cast<boost::uint32_t>(2637558u),
 801          static_cast<boost::uint32_t>(357423u),
 802          static_cast<boost::uint32_t>(32670u),
 803          static_cast<boost::uint32_t>(1925u),
 804          static_cast<boost::uint32_t>(66u),
 805          static_cast<boost::uint32_t>(1u)
 806       };
 807       return boost::math::tools::evaluate_rational(num, denom, z);
 808    }
 809
 810
 811    template<class T>
 812    static T lanczos_sum_near_1(const T& dz)
 813    {
 814       static const T d[12] = {
 815          static_cast<T>(2.208709979316623790862569924861841433016L),
 816          static_cast<T>(-3.327150580651624233553677113928873034916L),
 817          static_cast<T>(1.483082862367253753040442933770164111678L),
 818          static_cast<T>(-0.1993758927614728757314233026257810172008L),
 819          static_cast<T>(0.004785200610085071473880915854204301886437L),
 820          static_cast<T>(-0.1515973019871092388943437623825208095123e-5L),
 821          static_cast<T>(-0.2752907702903126466004207345038327818713e-7L),
 822          static_cast<T>(0.3075580174791348492737947340039992829546e-7L),
 823          static_cast<T>(-0.1933117898880828348692541394841204288047e-7L),
 824          static_cast<T>(0.8690926181038057039526127422002498960172e-8L),
 825          static_cast<T>(-0.2499505151487868335680273909354071938387e-8L),
 826          static_cast<T>(0.3394643171893132535170101292240837927725e-9L),
 827       };
 828       T result = 0;
 829       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 830       {
 831          result += (-d[k-1]*dz)/(k*dz + k*k);
 832       }
 833       return result;
 834    }
 835
 836    template<class T>
 837    static T lanczos_sum_near_2(const T& dz)
 838    {
 839       static const T d[12] = {
 840          static_cast<T>(6.565936202082889535528455955485877361223L),
 841          static_cast<T>(-9.8907772644920670589288081640128194231L),
 842          static_cast<T>(4.408830289125943377923077727900630927902L),
 843          static_cast<T>(-0.5926941084905061794445733628891024027949L),
 844          static_cast<T>(0.01422519127192419234315002746252160965831L),
 845          static_cast<T>(-0.4506604409707170077136555010018549819192e-5L),
 846          static_cast<T>(-0.8183698410724358930823737982119474130069e-7L),
 847          static_cast<T>(0.9142922068165324132060550591210267992072e-7L),
 848          static_cast<T>(-0.5746670642147041587497159649318454348117e-7L),
 849          static_cast<T>(0.2583592566524439230844378948704262291927e-7L),
 850          static_cast<T>(-0.7430396708998719707642735577238449585822e-8L),
 851          static_cast<T>(0.1009141566987569892221439918230042368112e-8L),
 852       };
 853       T result = 0;
 854       T z = dz + 2;
 855       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 856       {
 857          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
 858       }
 859       return result;
 860    }
 861
 862    static double g(){ return 6.024680040776729583740234375; }
 863 };
 864
 865 //
 866 // Lanczos Coefficients for N=17 G=12.2252227365970611572265625
 867 // Max experimental error (with arbitary precision arithmetic) 2.7699e-26
 868 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
 869 //
 870 struct lanczos17m64 : public mpl::int_<64>
 871 {
 872    //
 873    // Use for extended-double precision, when evaluated as an extended-double:
 874    //
 875    template <class T>
 876    static T lanczos_sum(const T& z)
 877    {
 878       lanczos_initializer<lanczos17m64, T>::force_instantiate(); // Ensure our constants get initialized before main()
 879       static const T num[17] = {
 880          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 553681095419291969.2230556393350368550504)),
 881          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 731918863887667017.2511276782146694632234)),
 882          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 453393234285807339.4627124634539085143364)),
 883          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 174701893724452790.3546219631779712198035)),
 884          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 46866125995234723.82897281620357050883077)),
 885          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9281280675933215.169109622777099699054272)),
 886          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1403600894156674.551057997617468721789536)),
 887          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 165345984157572.7305349809894046783973837)),
 888          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 15333629842677.31531822808737907246817024)),
 889          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1123152927963.956626161137169462874517318)),
 890          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 64763127437.92329018717775593533620578237)),
 891          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2908830362.657527782848828237106640944457)),
 892          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 99764700.56999856729959383751710026787811)),
 893          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2525791.604886139959837791244686290089331)),
 894          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 44516.94034970167828580039370201346554872)),
 895          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 488.0063567520005730476791712814838113252)),
 896          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.50662827463100050241576877135758834683))
 897       };
 898       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint64_t) denom[17] = {
 899          BOOST_MATH_INT_VALUE_SUFFIX(0, uLL),
 900          BOOST_MATH_INT_VALUE_SUFFIX(1307674368000, uLL),
 901          BOOST_MATH_INT_VALUE_SUFFIX(4339163001600, uLL),
 902          BOOST_MATH_INT_VALUE_SUFFIX(6165817614720, uLL),
 903          BOOST_MATH_INT_VALUE_SUFFIX(5056995703824, uLL),
 904          BOOST_MATH_INT_VALUE_SUFFIX(2706813345600, uLL),
 905          BOOST_MATH_INT_VALUE_SUFFIX(1009672107080, uLL),
 906          BOOST_MATH_INT_VALUE_SUFFIX(272803210680, uLL),
 907          BOOST_MATH_INT_VALUE_SUFFIX(54631129553, uLL),
 908          BOOST_MATH_INT_VALUE_SUFFIX(8207628000, uLL),
 909          BOOST_MATH_INT_VALUE_SUFFIX(928095740, uLL),
 910          BOOST_MATH_INT_VALUE_SUFFIX(78558480, uLL),
 911          BOOST_MATH_INT_VALUE_SUFFIX(4899622, uLL),
 912          BOOST_MATH_INT_VALUE_SUFFIX(218400, uLL),
 913          BOOST_MATH_INT_VALUE_SUFFIX(6580, uLL),
 914          BOOST_MATH_INT_VALUE_SUFFIX(120, uLL),
 915          BOOST_MATH_INT_VALUE_SUFFIX(1, uLL)
 916       };
 917       return boost::math::tools::evaluate_rational(num, denom, z);
 918    }
 919
 920    template <class T>
 921    static T lanczos_sum_expG_scaled(const T& z)
 922    {
 923       lanczos_initializer<lanczos17m64, T>::force_instantiate(); // Ensure our constants get initialized before main()
 924       static const T num[17] = {
 925          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2715894658327.717377557655133124376674911)),
 926          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3590179526097.912105038525528721129550434)),
 927          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2223966599737.814969312127353235818710172)),
 928          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 856940834518.9562481809925866825485883417)),
 929          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 229885871668.749072933597446453399395469)),
 930          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 45526171687.54610815813502794395753410032)),
 931          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 6884887713.165178784550917647709216424823)),
 932          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 811048596.1407531864760282453852372777439)),
 933          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 75213915.96540822314499613623119501704812)),
 934          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 5509245.417224265151697527957954952830126)),
 935          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 317673.5368435419126714931842182369574221)),
 936          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 14268.27989845035520147014373320337523596)),
 937          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 489.3618720403263670213909083601787814792)),
 938          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 12.38941330038454449295883217865458609584)),
 939          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.2183627389504614963941574507281683147897)),
 940          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.002393749522058449186690627996063983095463)),
 941          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.1229541408909435212800785616808830746135e-4))
 942       };
 943       static const BOOST_MATH_INT_TABLE_TYPE(T, boost::uint64_t) denom[17] = {
 944          BOOST_MATH_INT_VALUE_SUFFIX(0, uLL),
 945          BOOST_MATH_INT_VALUE_SUFFIX(1307674368000, uLL),
 946          BOOST_MATH_INT_VALUE_SUFFIX(4339163001600, uLL),
 947          BOOST_MATH_INT_VALUE_SUFFIX(6165817614720, uLL),
 948          BOOST_MATH_INT_VALUE_SUFFIX(5056995703824, uLL),
 949          BOOST_MATH_INT_VALUE_SUFFIX(2706813345600, uLL),
 950          BOOST_MATH_INT_VALUE_SUFFIX(1009672107080, uLL),
 951          BOOST_MATH_INT_VALUE_SUFFIX(272803210680, uLL),
 952          BOOST_MATH_INT_VALUE_SUFFIX(54631129553, uLL),
 953          BOOST_MATH_INT_VALUE_SUFFIX(8207628000, uLL),
 954          BOOST_MATH_INT_VALUE_SUFFIX(928095740, uLL),
 955          BOOST_MATH_INT_VALUE_SUFFIX(78558480, uLL),
 956          BOOST_MATH_INT_VALUE_SUFFIX(4899622, uLL),
 957          BOOST_MATH_INT_VALUE_SUFFIX(218400, uLL),
 958          BOOST_MATH_INT_VALUE_SUFFIX(6580, uLL),
 959          BOOST_MATH_INT_VALUE_SUFFIX(120, uLL),
 960          BOOST_MATH_INT_VALUE_SUFFIX(1, uLL)
 961       };
 962       return boost::math::tools::evaluate_rational(num, denom, z);
 963    }
 964
 965
 966    template<class T>
 967    static T lanczos_sum_near_1(const T& dz)
 968    {
 969       lanczos_initializer<lanczos17m64, T>::force_instantiate(); // Ensure our constants get initialized before main()
 970       static const T d[16] = {
 971          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.493645054286536365763334986866616581265)),
 972          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -16.95716370392468543800733966378143997694)),
 973          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 26.19196892983737527836811770970479846644)),
 974          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -21.3659076437988814488356323758179283908)),
 975          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.913992596774556590710751047594507535764)),
 976          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.62888300018780199210536267080940382158)),
 977          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.3807056693542503606384861890663080735588)),
 978          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.02714647489697685807340312061034730486958)),
 979          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.0007815484715461206757220527133967191796747)),
 980          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.6108630817371501052576880554048972272435e-5)),
 981          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.5037380238864836824167713635482801545086e-8)),
 982          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.1483232144262638814568926925964858237006e-13)),
 983          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.1346609158752142460943888149156716841693e-14)),
 984          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.660492688923978805315914918995410340796e-15)),
 985          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.1472114697343266749193617793755763792681e-15)),
 986          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.1410901942033374651613542904678399264447e-16)),
 987       };
 988       T result = 0;
 989       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
 990       {
 991          result += (-d[k-1]*dz)/(k*dz + k*k);
 992       }
 993       return result;
 994    }
 995
 996    template<class T>
 997    static T lanczos_sum_near_2(const T& dz)
 998    {
 999       lanczos_initializer<lanczos17m64, T>::force_instantiate(); // Ensure our constants get initialized before main()
1000       static const T d[16] = {
1001          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 23.56409085052261327114594781581930373708)),
1002          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -88.92116338946308797946237246006238652361)),
1003          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 137.3472822086847596961177383569603988797)),
1004          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -112.0400438263562152489272966461114852861)),
1005          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 51.98768915202973863076166956576777843805)),
1006          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -13.78552090862799358221343319574970124948)),
1007          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.996371068830872830250406773917646121742)),
1008          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.1423525874909934506274738563671862576161)),
1009          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.004098338646046865122459664947239111298524)),
1010          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.3203286637326511000882086573060433529094e-4)),
1011          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.2641536751640138646146395939004587594407e-7)),
1012          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.7777876663062235617693516558976641009819e-13)),
1013          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.7061443477097101636871806229515157914789e-14)),
1014          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.3463537849537988455590834887691613484813e-14)),
1015          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.7719578215795234036320348283011129450595e-15)),
1016          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -0.7398586479708476329563577384044188912075e-16)),
1017       };
1018       T result = 0;
1019       T z = dz + 2;
1020       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
1021       {
1022          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
1023       }
1024       return result;
1025    }
1026
1027    static double g(){ return 12.2252227365970611572265625; }
1028 };
1029
1030 //
1031 // Lanczos Coefficients for N=24 G=20.3209821879863739013671875
1032 // Max experimental error (with arbitary precision arithmetic) 1.0541e-38
1033 // Generated with compiler: Microsoft Visual C++ version 8.0 on Win32 at Mar 23 2006
1034 //
1035 struct lanczos24m113 : public mpl::int_<113>
1036 {
1037    //
1038    // Use for long-double precision, when evaluated as an long-double:
1039    //
1040    template <class T>
1041    static T lanczos_sum(const T& z)
1042    {
1043       lanczos_initializer<lanczos24m113, T>::force_instantiate(); // Ensure our constants get initialized before main()
1044       static const T num[24] = {
1045          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2029889364934367661624137213253.22102954656825019111612712252027267955023987678816620961507)),
1046          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2338599599286656537526273232565.2727349714338768161421882478417543004440597874814359063158)),
1047          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1288527989493833400335117708406.3953711906175960449186720680201425446299360322830739180195)),
1048          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 451779745834728745064649902914.550539158066332484594436145043388809847364393288132164411521)),
1049          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 113141284461097964029239556815.291212318665536114012605167994061291631013303788706545334708)),
1050          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 21533689802794625866812941616.7509064680880468667055339259146063256555368135236149614592432)),
1051          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3235510315314840089932120340.71494940111731241353655381919722177496659303550321056514776757)),
1052          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 393537392344185475704891959.081297108513472083749083165179784098220158201055270548272414314)),
1053          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 39418265082950435024868801.5005452240816902251477336582325944930252142622315101857742955673)),
1054          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3290158764187118871697791.05850632319194734270969161036889516414516566453884272345518372696)),
1055          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 230677110449632078321772.618245845856640677845629174549731890660612368500786684333975350954)),
1056          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 13652233645509183190158.5916189185218250859402806777406323001463296297553612462737044693697)),
1057          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 683661466754325350495.216655026531202476397782296585200982429378069417193575896602446904762)),
1058          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 28967871782219334117.0122379171041074970463982134039409352925258212207710168851968215545064)),
1059          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1036104088560167006.2022834098572346459442601718514554488352117620272232373622553429728555)),
1060          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 31128490785613152.8380102669349814751268126141105475287632676569913936040772990253369753962)),
1061          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 779327504127342.536207878988196814811198475410572992436243686674896894543126229424358472541)),
1062          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 16067543181294.643350688789124777020407337133926174150582333950666044399234540521336771876)),
1063          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 268161795520.300916569439413185778557212729611517883948634711190170998896514639936969855484)),
1064          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3533216359.10528191668842486732408440112703691790824611391987708562111396961696753452085068)),
1065          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 35378979.5479656110614685178752543826919239614088343789329169535932709470588426584501652577)),
1066          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 253034.881362204346444503097491737872930637147096453940375713745904094735506180552724766444)),
1067          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1151.61895453463992438325318456328526085882924197763140514450975619271382783957699017875304)),
1068          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2.50662827463100050241576528481104515966515623051532908941425544355490413900497467936202516))
1069       };
1070       static const T denom[24] = {
1071          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0)),
1072          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.112400072777760768e22)),
1073          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.414847677933545472e22)),
1074          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 6756146673770930688000.0)),
1075          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 6548684852703068697600.0)),
1076          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4280722865357147142912.0)),
1077          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2021687376910682741568.0)),
1078          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 720308216440924653696.0)),
1079          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 199321978221066137360.0)),
1080          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 43714229649594412832.0)),
1081          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 7707401101297361068.0)),
1082          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1103230881185949736.0)),
1083          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 129006659818331295.0)),
1084          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 12363045847086207.0)),
1085          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 971250460939913.0)),
1086          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 62382416421941.0)),
1087          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3256091103430.0)),
1088          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 136717357942.0)),
1089          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4546047198.0)),
1090          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 116896626)),
1091          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2240315)),
1092          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 30107)),
1093          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 253)),
1094          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1))
1095       };
1096       return boost::math::tools::evaluate_rational(num, denom, z);
1097    }
1098
1099    template <class T>
1100    static T lanczos_sum_expG_scaled(const T& z)
1101    {
1102       lanczos_initializer<lanczos24m113, T>::force_instantiate(); // Ensure our constants get initialized before main()
1103       static const T num[24] = {
1104          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3035162425359883494754.02878223286972654682199012688209026810841953293372712802258398358538)),
1105          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3496756894406430103600.16057175075063458536101374170860226963245118484234495645518505519827)),
1106          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1926652656689320888654.01954015145958293168365236755537645929361841917596501251362171653478)),
1107          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 675517066488272766316.083023742440619929434602223726894748181327187670231286180156444871912)),
1108          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 169172853104918752780.086262749564831660238912144573032141700464995906149421555926000038492)),
1109          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 32197935167225605785.6444116302160245528783954573163541751756353183343357329404208062043808)),
1110          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4837849542714083249.37587447454818124327561966323276633775195138872820542242539845253171632)),
1111          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 588431038090493242.308438203986649553459461798968819276505178004064031201740043314534404158)),
1112          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 58939585141634058.6206417889192563007809470547755357240808035714047014324843817783741669733)),
1113          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4919561837722192.82991866530802080996138070630296720420704876654726991998309206256077395868)),
1114          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 344916580244240.407442753122831512004021081677987651622305356145640394384006997569631719101)),
1115          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 20413302960687.8250598845969238472629322716685686993835561234733641729957841485003560103066)),
1116          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1022234822943.78400752460970689311934727763870970686747383486600540378889311406851534545789)),
1117          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 43313787191.9821354846952908076307094286897439975815501673706144217246093900159173598852503)),
1118          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1549219505.59667418528481770869280437577581951167003505825834192510436144666564648361001914)),
1119          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 46544421.1998761919380541579358096705925369145324466147390364674998568485110045455014967149)),
1120          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1165278.06807504975090675074910052763026564833951579556132777702952882101173607903881127542)),
1121          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 24024.759267256769471083727721827405338569868270177779485912486668586611981795179894572115)),
1122          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 400.965008113421955824358063769761286758463521789765880962939528760888853281920872064838918)),
1123          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 5.28299015654478269617039029170846385138134929147421558771949982217659507918482272439717603)),
1124          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.0528999024412510102409256676599360516359062802002483877724963720047531347449011629466149805)),
1125          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.000378346710654740685454266569593414561162134092347356968516522170279688139165340746957511115)),
1126          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.172194142179211139195966608011235161516824700287310869949928393345257114743230967204370963e-5)),
1127          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.374799931707148855771381263542708435935402853962736029347951399323367765509988401336565436e-8))
1128       };
1129       static const T denom[24] = {
1130          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0)),
1131          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.112400072777760768e22)),
1132          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.414847677933545472e22)),
1133          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 6756146673770930688000.0)),
1134          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 6548684852703068697600.0)),
1135          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4280722865357147142912.0)),
1136          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2021687376910682741568.0)),
1137          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 720308216440924653696.0)),
1138          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 199321978221066137360.0)),
1139          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 43714229649594412832.0)),
1140          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 7707401101297361068.0)),
1141          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1103230881185949736.0)),
1142          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 129006659818331295.0)),
1143          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 12363045847086207.0)),
1144          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 971250460939913.0)),
1145          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 62382416421941.0)),
1146          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 3256091103430.0)),
1147          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 136717357942.0)),
1148          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4546047198.0)),
1149          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 116896626)),
1150          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2240315)),
1151          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 30107)),
1152          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 253)),
1153          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1))
1154       };
1155       return boost::math::tools::evaluate_rational(num, denom, z);
1156    }
1157
1158
1159    template<class T>
1160    static T lanczos_sum_near_1(const T& dz)
1161    {
1162       lanczos_initializer<lanczos24m113, T>::force_instantiate(); // Ensure our constants get initialized before main()
1163       static const T d[23] = {
1164          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 7.4734083002469026177867421609938203388868806387315406134072298925733950040583068760685908)),
1165          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -50.4225805042247530267317342133388132970816607563062253708655085754357843064134941138154171)),
1166          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 152.288200621747008570784082624444625293884063492396162110698238568311211546361189979357019)),
1167          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -271.894959539150384169327513139846971255640842175739337449692360299099322742181325023644769)),
1168          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 319.240102980202312307047586791116902719088581839891008532114107693294261542869734803906793)),
1169          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -259.493144143048088289689500935518073716201741349569864988870534417890269467336454358361499)),
1170          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 149.747518319689708813209645403067832020714660918583227716408482877303972685262557460145835)),
1171          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -61.9261301009341333289187201425188698128684426428003249782448828881580630606817104372760037)),
1172          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 18.3077524177286961563937379403377462608113523887554047531153187277072451294845795496072365)),
1173          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -3.82011322251948043097070160584761236869363471824695092089556195047949392738162970152230254)),
1174          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.549382685505691522516705902336780999493262538301283190963770663549981309645795228539620711)),
1175          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.0524814679715180697633723771076668718265358076235229045603747927518423453658004287459638024)),
1176          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.00315392664003333528534120626687784812050217700942910879712808180705014754163256855643360698)),
1177          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.000110098373127648510519799564665442121339511198561008748083409549601095293123407080388658329)),
1178          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.19809382866681658224945717689377373458866950897791116315219376038432014207446832310901893e-5)),
1179          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.152278977408600291408265615203504153130482270424202400677280558181047344681214058227949755e-7)),
1180          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.364344768076106268872239259083188037615571711218395765792787047015406264051536972018235217e-10)),
1181          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.148897510480440424971521542520683536298361220674662555578951242811522959610991621951203526e-13)),
1182          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.261199241161582662426512749820666625442516059622425213340053324061794752786482115387573582e-18)),
1183          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.780072664167099103420998436901014795601783313858454665485256897090476089641613851903791529e-24)),
1184          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.303465867587106629530056603454807425512962762653755513440561256044986695349304176849392735e-24)),
1185          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.615420597971283870342083342286977366161772327800327789325710571275345878439656918541092056e-25)),
1186          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.499641233843540749369110053005439398774706583601830828776209650445427083113181961630763702e-26)),
1187       };
1188       T result = 0;
1189       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
1190       {
1191          result += (-d[k-1]*dz)/(k*dz + k*k);
1192       }
1193       return result;
1194    }
1195
1196    template<class T>
1197    static T lanczos_sum_near_2(const T& dz)
1198    {
1199       lanczos_initializer<lanczos24m113, T>::force_instantiate(); // Ensure our constants get initialized before main()
1200       static const T d[23] = {
1201          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 61.4165001061101455341808888883960361969557848005400286332291451422461117307237198559485365)),
1202          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -414.372973678657049667308134761613915623353625332248315105320470271523320700386200587519147)),
1203          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1251.50505818554680171298972755376376836161706773644771875668053742215217922228357204561873)),
1204          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -2234.43389421602399514176336175766511311493214354568097811220122848998413358085613880612158)),
1205          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2623.51647746991904821899989145639147785427273427135380151752779100215839537090464785708684)),
1206          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -2132.51572435428751962745870184529534443305617818870214348386131243463614597272260797772423)),
1207          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1230.62572059218405766499842067263311220019173335523810725664442147670956427061920234820189)),
1208          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -508.90919151163744999377586956023909888833335885805154492270846381061182696305011395981929)),
1209          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 150.453184562246579758706538566480316921938628645961177699894388251635886834047343195475395)),
1210          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -31.3937061525822497422230490071156186113405446381476081565548185848237169870395131828731397)),
1211          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 4.51482916590287954234936829724231512565732528859217337795452389161322923867318809206313688)),
1212          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.431292919341108177524462194102701868233551186625103849565527515201492276412231365776131952)),
1213          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.0259189820815586225636729971503340447445001375909094681698918294680345547092233915092128323)),
1214          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.000904788882557558697594884691337532557729219389814315972435534723829065673966567231504429712)),
1215          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.162793589759218213439218473348810982422449144393340433592232065020562974405674317564164312e-4)),
1216          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.125142926178202562426432039899709511761368233479483128438847484617555752948755923647214487e-6)),
1217          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.299418680048132583204152682950097239197934281178261879500770485862852229898797687301941982e-9)),
1218          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.122364035267809278675627784883078206654408225276233049012165202996967011873995261617995421e-12)),
1219          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.21465364366598631597052073538883430194257709353929022544344097235100199405814005393447785e-17)),
1220          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.641064035802907518396608051803921688237330857546406669209280666066685733941549058513986818e-23)),
1221          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.249388374622173329690271566855185869111237201309011956145463506483151054813346819490278951e-23)),
1222          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, -0.505752900177513489906064295001851463338022055787536494321532352380960774349054239257683149e-24)),
1223          static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 0.410605371184590959139968810080063542546949719163227555918846829816144878123034347778284006e-25)),
1224       };
1225       T result = 0;
1226       T z = dz + 2;
1227       for(unsigned k = 1; k <= sizeof(d)/sizeof(d[0]); ++k)
1228       {
1229          result += (-d[k-1]*dz)/(z + k*z + k*k - 1);
1230       }
1231       return result;
1232    }
1233
1234    static double g(){ return 20.3209821879863739013671875; }
1235 };
1236
1237
1238 //
1239 // placeholder for no lanczos info available:
1240 //
1241 struct undefined_lanczos : public mpl::int_<INT_MAX - 1> { };
1242
1243 #if 0
1244 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
1245 #define BOOST_MATH_FLT_DIGITS ::std::numeric_limits<float>::digits
1246 #define BOOST_MATH_DBL_DIGITS ::std::numeric_limits<double>::digits
1247 #define BOOST_MATH_LDBL_DIGITS ::std::numeric_limits<long double>::digits
1248 #else
1249 #define BOOST_MATH_FLT_DIGITS FLT_MANT_DIG
1250 #define BOOST_MATH_DBL_DIGITS DBL_MANT_DIG
1251 #define BOOST_MATH_LDBL_DIGITS LDBL_MANT_DIG
1252 #endif
1253 #endif
1254
1255 typedef mpl::list<
1256    lanczos6m24,
1257 /*   lanczos6, */
1258    lanczos13m53,
1259 /*   lanczos13, */
1260    lanczos17m64,
1261    lanczos24m113,
1262    lanczos22,
1263    undefined_lanczos> lanczos_list;
1264
1265 template <class Real, class Policy>
1266 struct lanczos
1267 {
1268    typedef typename mpl::if_<
1269       typename mpl::less_equal<
1270          typename policies::precision<Real, Policy>::type,
1271          mpl::int_<0>
1272       >::type,
1273       mpl::int_<INT_MAX - 2>,
1274       typename policies::precision<Real, Policy>::type
1275    >::type target_precision;
1276
1277    typedef typename mpl::deref<typename mpl::find_if<
1278       lanczos_list,
1279       mpl::less_equal<target_precision, mpl::_1> >::type>::type type;
1280 };
1281
1282 } // namespace lanczos
1283 } // namespace math
1284 } // namespace boost
1285
1286 #if !defined(_CRAYC) && !defined(__CUDACC__) && (!defined(__GNUC__) || (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 3)))
1287 #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || defined(__SSE2__)
1288 #include <boost/math/special_functions/detail/lanczos_sse2.hpp>
1289 #endif
1290 #endif
1291
1292 #endif // BOOST_MATH_SPECIAL_FUNCTIONS_LANCZOS
1293
1294
1295
1296