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 { initboost::math::lanczos::lanczos_initializer::init46 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 } force_instantiateboost::math::lanczos::lanczos_initializer::init55 void force_instantiate()const{} 56 }; 57 static const init initializer; force_instantiateboost::math::lanczos::lanczos_initializer58 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> lanczos_sumboost::math::lanczos::lanczos677 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos6100 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> lanczos_sum_near_1boost::math::lanczos::lanczos6124 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> lanczos_sum_near_2boost::math::lanczos::lanczos6143 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 gboost::math::lanczos::lanczos6162 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> lanczos_sumboost::math::lanczos::lanczos11177 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos11210 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> lanczos_sum_near_1boost::math::lanczos::lanczos11244 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> lanczos_sum_near_2boost::math::lanczos::lanczos11268 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 gboost::math::lanczos::lanczos11292 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> lanczos_sumboost::math::lanczos::lanczos13307 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos13344 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> lanczos_sum_near_1boost::math::lanczos::lanczos13382 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> lanczos_sum_near_2boost::math::lanczos::lanczos13408 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 gboost::math::lanczos::lanczos13434 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> lanczos_sumboost::math::lanczos::lanczos22449 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos22504 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> lanczos_sum_near_1boost::math::lanczos::lanczos22560 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> lanczos_sum_near_2boost::math::lanczos::lanczos22595 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 gboost::math::lanczos::lanczos22630 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> lanczos_sumboost::math::lanczos::lanczos6m24644 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos6m24666 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> lanczos_sum_near_1boost::math::lanczos::lanczos6m24689 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> lanczos_sum_near_2boost::math::lanczos::lanczos6m24707 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 gboost::math::lanczos::lanczos6m24725 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> lanczos_sumboost::math::lanczos::lanczos13m53739 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos13m53775 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> lanczos_sum_near_1boost::math::lanczos::lanczos13m53812 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> lanczos_sum_near_2boost::math::lanczos::lanczos13m53837 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 gboost::math::lanczos::lanczos13m53862 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> lanczos_sumboost::math::lanczos::lanczos17m64876 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> lanczos_sum_expG_scaledboost::math::lanczos::lanczos17m64921 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> lanczos_sum_near_1boost::math::lanczos::lanczos17m64967 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> lanczos_sum_near_2boost::math::lanczos::lanczos17m64997 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 gboost::math::lanczos::lanczos17m641027 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> lanczos_sumboost::math::lanczos::lanczos24m1131041 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.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.0)), 1091 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2240315.0)), 1092 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 30107.0)), 1093 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 253.0)), 1094 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1.0)) 1095 }; 1096 return boost::math::tools::evaluate_rational(num, denom, z); 1097 } 1098 1099 template <class T> lanczos_sum_expG_scaledboost::math::lanczos::lanczos24m1131100 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.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.0)), 1150 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 2240315.0)), 1151 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 30107.0)), 1152 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 253.0)), 1153 static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 113, 1.0)) 1154 }; 1155 return boost::math::tools::evaluate_rational(num, denom, z); 1156 } 1157 1158 1159 template<class T> lanczos_sum_near_1boost::math::lanczos::lanczos24m1131160 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> lanczos_sum_near_2boost::math::lanczos::lanczos24m1131197 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 gboost::math::lanczos::lanczos24m1131234 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__) || defined(_M_AMD64) || defined(_M_X64) 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 1297