math/quadrature/gauss.hpp

0001 //  Copyright John Maddock 2015.
0002 //  Use, modification and distribution are subject to the
0003 //  Boost Software License, Version 1.0. (See accompanying file
0004 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0005
0006 #ifndef BOOST_MATH_QUADRATURE_GAUSS_HPP
0007 #define BOOST_MATH_QUADRATURE_GAUSS_HPP
0008
0009 #ifdef _MSC_VER
0010 #pragma once
0011 #endif
0012
0013 #include <limits>
0014 #include <vector>
0015 #include <boost/math/special_functions/legendre.hpp>
0016 #include <boost/math/constants/constants.hpp>
0017
0018 #ifdef _MSC_VER
0019 #pragma warning(push)
0020 #pragma warning(disable:4127)
0021 #endif
0022
0023 namespace boost { namespace math{ namespace quadrature{ namespace detail{
0024
0025 template <class T>
0026 struct gauss_constant_category
0027 {
0028    static const unsigned value =
0029       (std::numeric_limits<T>::is_specialized == 0) ? 999 :
0030       (std::numeric_limits<T>::radix == 2) ?
0031       (
0032          (std::numeric_limits<T>::digits <= std::numeric_limits<float>::digits) && std::is_convertible<float, T>::value ? 0 :
0033          (std::numeric_limits<T>::digits <= std::numeric_limits<double>::digits) && std::is_convertible<double, T>::value ? 1 :
0034          (std::numeric_limits<T>::digits <= std::numeric_limits<long double>::digits) && std::is_convertible<long double, T>::value ? 2 :
0035 #ifdef BOOST_HAS_FLOAT128
0036          (std::numeric_limits<T>::digits <= 113) && std::is_constructible<__float128, T>::value ? 3 :
0037 #endif
0038          (std::numeric_limits<T>::digits10 <= 110) ? 4 : 999
0039       ) : (std::numeric_limits<T>::digits10 <= 110) ? 4 : 999;
0040 };
0041
0042 #ifndef BOOST_MATH_GAUSS_NO_COMPUTE_ON_DEMAND
0043
0044 template <class Real, unsigned N, unsigned Category>
0045 class gauss_detail
0046 {
0047    static std::vector<Real> calculate_weights()
0048    {
0049       std::vector<Real> result(abscissa().size(), 0);
0050       for (unsigned i = 0; i < abscissa().size(); ++i)
0051       {
0052          Real x = abscissa()[i];
0053          Real p = boost::math::legendre_p_prime(N, x);
0054          result[i] = 2 / ((1 - x * x) * p * p);
0055       }
0056       return result;
0057    }
0058 public:
0059    static const std::vector<Real>& abscissa()
0060    {
0061       static std::vector<Real> data = boost::math::legendre_p_zeros<Real>(N);
0062       return data;
0063    }
0064    static const std::vector<Real>& weights()
0065    {
0066       static std::vector<Real> data = calculate_weights();
0067       return data;
0068    }
0069 };
0070
0071 #else
0072
0073 template <class Real, unsigned N, unsigned Category>
0074 class gauss_detail;
0075
0076 #endif
0077
0078 template <class T>
0079 class gauss_detail<T, 7, 0>
0080 {
0081 public:
0082    static std::array<T, 4> const & abscissa()
0083    {
0084       static constexpr std::array<T, 4> data = {
0085          0.000000000e+00f,
0086          4.058451514e-01f,
0087          7.415311856e-01f,
0088          9.491079123e-01f,
0089       };
0090       return data;
0091    }
0092    static std::array<T, 4> const & weights()
0093    {
0094       static constexpr std::array<T, 4> data = {
0095          4.179591837e-01f,
0096          3.818300505e-01f,
0097          2.797053915e-01f,
0098          1.294849662e-01f,
0099       };
0100       return data;
0101    }
0102 };
0103
0104 template <class T>
0105 class gauss_detail<T, 7, 1>
0106 {
0107 public:
0108    static std::array<T, 4> const & abscissa()
0109    {
0110       static constexpr std::array<T, 4> data = {
0111          0.00000000000000000e+00,
0112          4.05845151377397167e-01,
0113          7.41531185599394440e-01,
0114          9.49107912342758525e-01,
0115       };
0116       return data;
0117    }
0118    static std::array<T, 4> const & weights()
0119    {
0120       static constexpr std::array<T, 4> data = {
0121          4.17959183673469388e-01,
0122          3.81830050505118945e-01,
0123          2.79705391489276668e-01,
0124          1.29484966168869693e-01,
0125       };
0126       return data;
0127    }
0128 };
0129
0130 template <class T>
0131 class gauss_detail<T, 7, 2>
0132 {
0133 public:
0134    static std::array<T, 4> const & abscissa()
0135    {
0136       static constexpr std::array<T, 4> data = {
0137          0.00000000000000000000000000000000000e+00L,
0138          4.05845151377397166906606412076961463e-01L,
0139          7.41531185599394439863864773280788407e-01L,
0140          9.49107912342758524526189684047851262e-01L,
0141       };
0142       return data;
0143    }
0144    static std::array<T, 4> const & weights()
0145    {
0146       static constexpr std::array<T, 4> data = {
0147          4.17959183673469387755102040816326531e-01L,
0148          3.81830050505118944950369775488975134e-01L,
0149          2.79705391489276667901467771423779582e-01L,
0150          1.29484966168869693270611432679082018e-01L,
0151       };
0152       return data;
0153    }
0154 };
0155 #ifdef BOOST_HAS_FLOAT128
0156 template <class T>
0157 class gauss_detail<T, 7, 3>
0158 {
0159 public:
0160    static std::array<T, 4> const & abscissa()
0161    {
0162       static const std::array<T, 4> data = {
0163          0.00000000000000000000000000000000000e+00Q,
0164          4.05845151377397166906606412076961463e-01Q,
0165          7.41531185599394439863864773280788407e-01Q,
0166          9.49107912342758524526189684047851262e-01Q,
0167       };
0168       return data;
0169    }
0170    static std::array<T, 4> const & weights()
0171    {
0172       static const std::array<T, 4> data = {
0173          4.17959183673469387755102040816326531e-01Q,
0174          3.81830050505118944950369775488975134e-01Q,
0175          2.79705391489276667901467771423779582e-01Q,
0176          1.29484966168869693270611432679082018e-01Q,
0177       };
0178       return data;
0179    }
0180 };
0181 #endif
0182 template <class T>
0183 class gauss_detail<T, 7, 4>
0184 {
0185 public:
0186    static  std::array<T, 4> const & abscissa()
0187    {
0188       static  std::array<T, 4> data = {
0189          BOOST_MATH_HUGE_CONSTANT(T, 0, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00),
0190          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.0584515137739716690660641207696146334738201409937012638704325179466381322612565532831268972774658776528675866604802e-01),
0191          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.4153118559939443986386477328078840707414764714139026011995535196742987467218051379282683236686324705969251809311201e-01),
0192          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.4910791234275852452618968404785126240077093767061778354876910391306333035484014080573077002792572414430073966699522e-01),
0193       };
0194       return data;
0195    }
0196    static  std::array<T, 4> const & weights()
0197    {
0198       static  std::array<T, 4> data = {
0199          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.1795918367346938775510204081632653061224489795918367346938775510204081632653061224489795918367346938775510204081633e-01),
0200          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.8183005050511894495036977548897513387836508353386273475108345103070554643412970834868465934404480145031467176458536e-01),
0201          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.7970539148927666790146777142377958248692506522659876453701403269361881043056267681324094290119761876632337521337205e-01),
0202          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2948496616886969327061143267908201832858740225994666397720863872465523497204230871562541816292084508948440200163443e-01),
0203       };
0204       return data;
0205    }
0206 };
0207
0208 template <class T>
0209 class gauss_detail<T, 10, 0>
0210 {
0211 public:
0212    static std::array<T, 5> const & abscissa()
0213    {
0214       static constexpr std::array<T, 5> data = {
0215          1.488743390e-01f,
0216          4.333953941e-01f,
0217          6.794095683e-01f,
0218          8.650633667e-01f,
0219          9.739065285e-01f,
0220       };
0221       return data;
0222    }
0223    static std::array<T, 5> const & weights()
0224    {
0225       static constexpr std::array<T, 5> data = {
0226          2.955242247e-01f,
0227          2.692667193e-01f,
0228          2.190863625e-01f,
0229          1.494513492e-01f,
0230          6.667134431e-02f,
0231       };
0232       return data;
0233    }
0234 };
0235
0236 template <class T>
0237 class gauss_detail<T, 10, 1>
0238 {
0239 public:
0240    static std::array<T, 5> const & abscissa()
0241    {
0242       static constexpr std::array<T, 5> data = {
0243          1.48874338981631211e-01,
0244          4.33395394129247191e-01,
0245          6.79409568299024406e-01,
0246          8.65063366688984511e-01,
0247          9.73906528517171720e-01,
0248       };
0249       return data;
0250    }
0251    static std::array<T, 5> const & weights()
0252    {
0253       static constexpr std::array<T, 5> data = {
0254          2.95524224714752870e-01,
0255          2.69266719309996355e-01,
0256          2.19086362515982044e-01,
0257          1.49451349150580593e-01,
0258          6.66713443086881376e-02,
0259       };
0260       return data;
0261    }
0262 };
0263
0264 template <class T>
0265 class gauss_detail<T, 10, 2>
0266 {
0267 public:
0268    static std::array<T, 5> const & abscissa()
0269    {
0270       static constexpr std::array<T, 5> data = {
0271          1.48874338981631210884826001129719985e-01L,
0272          4.33395394129247190799265943165784162e-01L,
0273          6.79409568299024406234327365114873576e-01L,
0274          8.65063366688984510732096688423493049e-01L,
0275          9.73906528517171720077964012084452053e-01L,
0276       };
0277       return data;
0278    }
0279    static std::array<T, 5> const & weights()
0280    {
0281       static constexpr std::array<T, 5> data = {
0282          2.95524224714752870173892994651338329e-01L,
0283          2.69266719309996355091226921569469353e-01L,
0284          2.19086362515982043995534934228163192e-01L,
0285          1.49451349150580593145776339657697332e-01L,
0286          6.66713443086881375935688098933317929e-02L,
0287       };
0288       return data;
0289    }
0290 };
0291 #ifdef BOOST_HAS_FLOAT128
0292 template <class T>
0293 class gauss_detail<T, 10, 3>
0294 {
0295 public:
0296    static std::array<T, 5> const & abscissa()
0297    {
0298       static const std::array<T, 5> data = {
0299          1.48874338981631210884826001129719985e-01Q,
0300          4.33395394129247190799265943165784162e-01Q,
0301          6.79409568299024406234327365114873576e-01Q,
0302          8.65063366688984510732096688423493049e-01Q,
0303          9.73906528517171720077964012084452053e-01Q,
0304       };
0305       return data;
0306    }
0307    static std::array<T, 5> const & weights()
0308    {
0309       static const std::array<T, 5> data = {
0310          2.95524224714752870173892994651338329e-01Q,
0311          2.69266719309996355091226921569469353e-01Q,
0312          2.19086362515982043995534934228163192e-01Q,
0313          1.49451349150580593145776339657697332e-01Q,
0314          6.66713443086881375935688098933317929e-02Q,
0315       };
0316       return data;
0317    }
0318 };
0319 #endif
0320 template <class T>
0321 class gauss_detail<T, 10, 4>
0322 {
0323 public:
0324    static  std::array<T, 5> const & abscissa()
0325    {
0326       static  std::array<T, 5> data = {
0327          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4887433898163121088482600112971998461756485942069169570798925351590361735566852137117762979946369123003116080525534e-01),
0328          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.3339539412924719079926594316578416220007183765624649650270151314376698907770350122510275795011772122368293504099894e-01),
0329          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.7940956829902440623432736511487357576929471183480946766481718895255857539507492461507857357048037949983390204739932e-01),
0330          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.6506336668898451073209668842349304852754301496533045252195973184537475513805556135679072894604577069440463108641177e-01),
0331          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.7390652851717172007796401208445205342826994669238211923121206669659520323463615962572356495626855625823304251877421e-01),
0332       };
0333       return data;
0334    }
0335    static  std::array<T, 5> const & weights()
0336    {
0337       static  std::array<T, 5> data = {
0338          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.9552422471475287017389299465133832942104671702685360135430802975599593821715232927035659579375421672271716440125256e-01),
0339          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.6926671930999635509122692156946935285975993846088379580056327624215343231917927676422663670925276075559581145036870e-01),
0340          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.1908636251598204399553493422816319245877187052267708988095654363519991065295128124268399317720219278659121687281289e-01),
0341          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4945134915058059314577633965769733240255663966942736783547726875323865472663001094594726463473195191400575256104544e-01),
0342          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.6671344308688137593568809893331792857864834320158145128694881613412064084087101776785509685058877821090054714520419e-02),
0343       };
0344       return data;
0345    }
0346 };
0347
0348 template <class T>
0349 class gauss_detail<T, 15, 0>
0350 {
0351 public:
0352    static std::array<T, 8> const & abscissa()
0353    {
0354       static constexpr std::array<T, 8> data = {
0355          0.000000000e+00f,
0356          2.011940940e-01f,
0357          3.941513471e-01f,
0358          5.709721726e-01f,
0359          7.244177314e-01f,
0360          8.482065834e-01f,
0361          9.372733924e-01f,
0362          9.879925180e-01f,
0363       };
0364       return data;
0365    }
0366    static std::array<T, 8> const & weights()
0367    {
0368       static constexpr std::array<T, 8> data = {
0369          2.025782419e-01f,
0370          1.984314853e-01f,
0371          1.861610000e-01f,
0372          1.662692058e-01f,
0373          1.395706779e-01f,
0374          1.071592205e-01f,
0375          7.036604749e-02f,
0376          3.075324200e-02f,
0377       };
0378       return data;
0379    }
0380 };
0381
0382 template <class T>
0383 class gauss_detail<T, 15, 1>
0384 {
0385 public:
0386    static std::array<T, 8> const & abscissa()
0387    {
0388       static constexpr std::array<T, 8> data = {
0389          0.00000000000000000e+00,
0390          2.01194093997434522e-01,
0391          3.94151347077563370e-01,
0392          5.70972172608538848e-01,
0393          7.24417731360170047e-01,
0394          8.48206583410427216e-01,
0395          9.37273392400705904e-01,
0396          9.87992518020485428e-01,
0397       };
0398       return data;
0399    }
0400    static std::array<T, 8> const & weights()
0401    {
0402       static constexpr std::array<T, 8> data = {
0403          2.02578241925561273e-01,
0404          1.98431485327111576e-01,
0405          1.86161000015562211e-01,
0406          1.66269205816993934e-01,
0407          1.39570677926154314e-01,
0408          1.07159220467171935e-01,
0409          7.03660474881081247e-02,
0410          3.07532419961172684e-02,
0411       };
0412       return data;
0413    }
0414 };
0415
0416 template <class T>
0417 class gauss_detail<T, 15, 2>
0418 {
0419 public:
0420    static std::array<T, 8> const & abscissa()
0421    {
0422       static constexpr std::array<T, 8> data = {
0423          0.00000000000000000000000000000000000e+00L,
0424          2.01194093997434522300628303394596208e-01L,
0425          3.94151347077563369897207370981045468e-01L,
0426          5.70972172608538847537226737253910641e-01L,
0427          7.24417731360170047416186054613938010e-01L,
0428          8.48206583410427216200648320774216851e-01L,
0429          9.37273392400705904307758947710209471e-01L,
0430          9.87992518020485428489565718586612581e-01L,
0431       };
0432       return data;
0433    }
0434    static std::array<T, 8> const & weights()
0435    {
0436       static constexpr std::array<T, 8> data = {
0437          2.02578241925561272880620199967519315e-01L,
0438          1.98431485327111576456118326443839325e-01L,
0439          1.86161000015562211026800561866422825e-01L,
0440          1.66269205816993933553200860481208811e-01L,
0441          1.39570677926154314447804794511028323e-01L,
0442          1.07159220467171935011869546685869303e-01L,
0443          7.03660474881081247092674164506673385e-02L,
0444          3.07532419961172683546283935772044177e-02L,
0445       };
0446       return data;
0447    }
0448 };
0449 #ifdef BOOST_HAS_FLOAT128
0450 template <class T>
0451 class gauss_detail<T, 15, 3>
0452 {
0453 public:
0454    static std::array<T, 8> const & abscissa()
0455    {
0456       static const std::array<T, 8> data = {
0457          0.00000000000000000000000000000000000e+00Q,
0458          2.01194093997434522300628303394596208e-01Q,
0459          3.94151347077563369897207370981045468e-01Q,
0460          5.70972172608538847537226737253910641e-01Q,
0461          7.24417731360170047416186054613938010e-01Q,
0462          8.48206583410427216200648320774216851e-01Q,
0463          9.37273392400705904307758947710209471e-01Q,
0464          9.87992518020485428489565718586612581e-01Q,
0465       };
0466       return data;
0467    }
0468    static std::array<T, 8> const & weights()
0469    {
0470       static const std::array<T, 8> data = {
0471          2.02578241925561272880620199967519315e-01Q,
0472          1.98431485327111576456118326443839325e-01Q,
0473          1.86161000015562211026800561866422825e-01Q,
0474          1.66269205816993933553200860481208811e-01Q,
0475          1.39570677926154314447804794511028323e-01Q,
0476          1.07159220467171935011869546685869303e-01Q,
0477          7.03660474881081247092674164506673385e-02Q,
0478          3.07532419961172683546283935772044177e-02Q,
0479       };
0480       return data;
0481    }
0482 };
0483 #endif
0484 template <class T>
0485 class gauss_detail<T, 15, 4>
0486 {
0487 public:
0488    static  std::array<T, 8> const & abscissa()
0489    {
0490       static  std::array<T, 8> data = {
0491          BOOST_MATH_HUGE_CONSTANT(T, 0, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00),
0492          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.0119409399743452230062830339459620781283645446263767961594972460994823900302018760183625806752105908967902257386509e-01),
0493          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.9415134707756336989720737098104546836275277615869825503116534395160895778696141797549711416165976202589352169635648e-01),
0494          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.7097217260853884753722673725391064123838639628274960485326541705419537986975857948341462856982614477912646497026257e-01),
0495          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.2441773136017004741618605461393800963089929458410256355142342070412378167792521899610109760313432626923598549381925e-01),
0496          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.4820658341042721620064832077421685136625617473699263409572755876067507517414548519760771975082148085090373835713340e-01),
0497          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.3727339240070590430775894771020947124399627351530445790136307635020297379704552795054758617426808659746824044603157e-01),
0498          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.8799251802048542848956571858661258114697281712376148999999751558738843736901942471272205036831914497667516843990079e-01),
0499       };
0500       return data;
0501    }
0502    static  std::array<T, 8> const & weights()
0503    {
0504       static  std::array<T, 8> data = {
0505          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.0257824192556127288062019996751931483866215800947735679670411605143539875474607409339344071278803213535148267082999e-01),
0506          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.9843148532711157645611832644383932481869255995754199348473792792912479753343426813331499916481782320766020854889310e-01),
0507          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.8616100001556221102680056186642282450622601227792840281549572731001325550269916061894976888609932360539977709001384e-01),
0508          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.6626920581699393355320086048120881113090018009841290732186519056355356321227851771070517429241553621484461540657185e-01),
0509          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.3957067792615431444780479451102832252085027531551124320239112863108844454190781168076825736357133363814908889327664e-01),
0510          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0715922046717193501186954668586930341554371575810198068702238912187799485231579972568585713760862404439808767837506e-01),
0511          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.0366047488108124709267416450667338466708032754330719825907292914387055512874237044840452066693939219355489858595041e-02),
0512          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.0753241996117268354628393577204417721748144833434074264228285504237189467117168039038770732399404002516991188859473e-02),
0513       };
0514       return data;
0515    }
0516 };
0517
0518 template <class T>
0519 class gauss_detail<T, 20, 0>
0520 {
0521 public:
0522    static std::array<T, 10> const & abscissa()
0523    {
0524       static constexpr std::array<T, 10> data = {
0525          7.652652113e-02f,
0526          2.277858511e-01f,
0527          3.737060887e-01f,
0528          5.108670020e-01f,
0529          6.360536807e-01f,
0530          7.463319065e-01f,
0531          8.391169718e-01f,
0532          9.122344283e-01f,
0533          9.639719273e-01f,
0534          9.931285992e-01f,
0535       };
0536       return data;
0537    }
0538    static std::array<T, 10> const & weights()
0539    {
0540       static constexpr std::array<T, 10> data = {
0541          1.527533871e-01f,
0542          1.491729865e-01f,
0543          1.420961093e-01f,
0544          1.316886384e-01f,
0545          1.181945320e-01f,
0546          1.019301198e-01f,
0547          8.327674158e-02f,
0548          6.267204833e-02f,
0549          4.060142980e-02f,
0550          1.761400714e-02f,
0551       };
0552       return data;
0553    }
0554 };
0555
0556 template <class T>
0557 class gauss_detail<T, 20, 1>
0558 {
0559 public:
0560    static std::array<T, 10> const & abscissa()
0561    {
0562       static constexpr std::array<T, 10> data = {
0563          7.65265211334973338e-02,
0564          2.27785851141645078e-01,
0565          3.73706088715419561e-01,
0566          5.10867001950827098e-01,
0567          6.36053680726515025e-01,
0568          7.46331906460150793e-01,
0569          8.39116971822218823e-01,
0570          9.12234428251325906e-01,
0571          9.63971927277913791e-01,
0572          9.93128599185094925e-01,
0573       };
0574       return data;
0575    }
0576    static std::array<T, 10> const & weights()
0577    {
0578       static constexpr std::array<T, 10> data = {
0579          1.52753387130725851e-01,
0580          1.49172986472603747e-01,
0581          1.42096109318382051e-01,
0582          1.31688638449176627e-01,
0583          1.18194531961518417e-01,
0584          1.01930119817240435e-01,
0585          8.32767415767047487e-02,
0586          6.26720483341090636e-02,
0587          4.06014298003869413e-02,
0588          1.76140071391521183e-02,
0589       };
0590       return data;
0591    }
0592 };
0593
0594 template <class T>
0595 class gauss_detail<T, 20, 2>
0596 {
0597 public:
0598    static std::array<T, 10> const & abscissa()
0599    {
0600       static constexpr std::array<T, 10> data = {
0601          7.65265211334973337546404093988382110e-02L,
0602          2.27785851141645078080496195368574625e-01L,
0603          3.73706088715419560672548177024927237e-01L,
0604          5.10867001950827098004364050955250998e-01L,
0605          6.36053680726515025452836696226285937e-01L,
0606          7.46331906460150792614305070355641590e-01L,
0607          8.39116971822218823394529061701520685e-01L,
0608          9.12234428251325905867752441203298113e-01L,
0609          9.63971927277913791267666131197277222e-01L,
0610          9.93128599185094924786122388471320278e-01L,
0611       };
0612       return data;
0613    }
0614    static std::array<T, 10> const & weights()
0615    {
0616       static constexpr std::array<T, 10> data = {
0617          1.52753387130725850698084331955097593e-01L,
0618          1.49172986472603746787828737001969437e-01L,
0619          1.42096109318382051329298325067164933e-01L,
0620          1.31688638449176626898494499748163135e-01L,
0621          1.18194531961518417312377377711382287e-01L,
0622          1.01930119817240435036750135480349876e-01L,
0623          8.32767415767047487247581432220462061e-02L,
0624          6.26720483341090635695065351870416064e-02L,
0625          4.06014298003869413310399522749321099e-02L,
0626          1.76140071391521183118619623518528164e-02L,
0627       };
0628       return data;
0629    }
0630 };
0631 #ifdef BOOST_HAS_FLOAT128
0632 template <class T>
0633 class gauss_detail<T, 20, 3>
0634 {
0635 public:
0636    static std::array<T, 10> const & abscissa()
0637    {
0638       static const std::array<T, 10> data = {
0639          7.65265211334973337546404093988382110e-02Q,
0640          2.27785851141645078080496195368574625e-01Q,
0641          3.73706088715419560672548177024927237e-01Q,
0642          5.10867001950827098004364050955250998e-01Q,
0643          6.36053680726515025452836696226285937e-01Q,
0644          7.46331906460150792614305070355641590e-01Q,
0645          8.39116971822218823394529061701520685e-01Q,
0646          9.12234428251325905867752441203298113e-01Q,
0647          9.63971927277913791267666131197277222e-01Q,
0648          9.93128599185094924786122388471320278e-01Q,
0649       };
0650       return data;
0651    }
0652    static std::array<T, 10> const & weights()
0653    {
0654       static const std::array<T, 10> data = {
0655          1.52753387130725850698084331955097593e-01Q,
0656          1.49172986472603746787828737001969437e-01Q,
0657          1.42096109318382051329298325067164933e-01Q,
0658          1.31688638449176626898494499748163135e-01Q,
0659          1.18194531961518417312377377711382287e-01Q,
0660          1.01930119817240435036750135480349876e-01Q,
0661          8.32767415767047487247581432220462061e-02Q,
0662          6.26720483341090635695065351870416064e-02Q,
0663          4.06014298003869413310399522749321099e-02Q,
0664          1.76140071391521183118619623518528164e-02Q,
0665       };
0666       return data;
0667    }
0668 };
0669 #endif
0670 template <class T>
0671 class gauss_detail<T, 20, 4>
0672 {
0673 public:
0674    static  std::array<T, 10> const & abscissa()
0675    {
0676       static  std::array<T, 10> data = {
0677          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.6526521133497333754640409398838211004796266813497500804795244384256342048336978241545114181556215606998505646364133e-02),
0678          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.2778585114164507808049619536857462474308893768292747231463573920717134186355582779495212519096870803177373131560430e-01),
0679          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.7370608871541956067254817702492723739574632170568271182794861351564576437305952789589568363453337894476772208852815e-01),
0680          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.1086700195082709800436405095525099842549132920242683347234861989473497039076572814403168305086777919832943068843526e-01),
0681          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.3605368072651502545283669622628593674338911679936846393944662254654126258543013255870319549576130658211710937772596e-01),
0682          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.4633190646015079261430507035564159031073067956917644413954590606853535503815506468110411362064752061238490065167656e-01),
0683          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.3911697182221882339452906170152068532962936506563737325249272553286109399932480991922934056595764922060422035306914e-01),
0684          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.1223442825132590586775244120329811304918479742369177479588221915807089120871907893644472619292138737876039175464603e-01),
0685          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.6397192727791379126766613119727722191206032780618885606353759389204158078438305698001812525596471563131043491596423e-01),
0686          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9312859918509492478612238847132027822264713090165589614818413121798471762775378083944940249657220927472894034724419e-01),
0687       };
0688       return data;
0689    }
0690    static  std::array<T, 10> const & weights()
0691    {
0692       static  std::array<T, 10> data = {
0693          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.5275338713072585069808433195509759349194864511237859727470104981759745316273778153557248783650390593544001842813788e-01),
0694          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4917298647260374678782873700196943669267990408136831649621121780984442259558678069396132603521048105170913854567338e-01),
0695          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4209610931838205132929832506716493303451541339202030333736708298382808749793436761694922428320058260133068573666201e-01),
0696          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.3168863844917662689849449974816313491611051114698352699643649370885435642948093314355797518397262924510598005463625e-01),
0697          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1819453196151841731237737771138228700504121954896877544688995202017474835051151630572868782581901744606267543092317e-01),
0698          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0193011981724043503675013548034987616669165602339255626197161619685232202539434647534931576947985821375859035525483e-01),
0699          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.3276741576704748724758143222046206100177828583163290744882060785693082894079419471375190843790839349096116111932764e-02),
0700          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.2672048334109063569506535187041606351601076578436364099584345437974811033665678644563766056832203512603253399592073e-02),
0701          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.0601429800386941331039952274932109879090639989951536817606854561832296750987328295538920623044384976189825709675075e-02),
0702          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.7614007139152118311861962351852816362143105543336732524349326677348419259621847817403105542146097668703716227512570e-02),
0703       };
0704       return data;
0705    }
0706 };
0707
0708 template <class T>
0709 class gauss_detail<T, 25, 0>
0710 {
0711 public:
0712    static std::array<T, 13> const & abscissa()
0713    {
0714       static constexpr std::array<T, 13> data = {
0715          0.000000000e+00f,
0716          1.228646926e-01f,
0717          2.438668837e-01f,
0718          3.611723058e-01f,
0719          4.730027314e-01f,
0720          5.776629302e-01f,
0721          6.735663685e-01f,
0722          7.592592630e-01f,
0723          8.334426288e-01f,
0724          8.949919979e-01f,
0725          9.429745712e-01f,
0726          9.766639215e-01f,
0727          9.955569698e-01f,
0728       };
0729       return data;
0730    }
0731    static std::array<T, 13> const & weights()
0732    {
0733       static constexpr std::array<T, 13> data = {
0734          1.231760537e-01f,
0735          1.222424430e-01f,
0736          1.194557635e-01f,
0737          1.148582591e-01f,
0738          1.085196245e-01f,
0739          1.005359491e-01f,
0740          9.102826198e-02f,
0741          8.014070034e-02f,
0742          6.803833381e-02f,
0743          5.490469598e-02f,
0744          4.093915670e-02f,
0745          2.635498662e-02f,
0746          1.139379850e-02f,
0747       };
0748       return data;
0749    }
0750 };
0751
0752 template <class T>
0753 class gauss_detail<T, 25, 1>
0754 {
0755 public:
0756    static std::array<T, 13> const & abscissa()
0757    {
0758       static constexpr std::array<T, 13> data = {
0759          0.00000000000000000e+00,
0760          1.22864692610710396e-01,
0761          2.43866883720988432e-01,
0762          3.61172305809387838e-01,
0763          4.73002731445714961e-01,
0764          5.77662930241222968e-01,
0765          6.73566368473468364e-01,
0766          7.59259263037357631e-01,
0767          8.33442628760834001e-01,
0768          8.94991997878275369e-01,
0769          9.42974571228974339e-01,
0770          9.76663921459517511e-01,
0771          9.95556969790498098e-01,
0772       };
0773       return data;
0774    }
0775    static std::array<T, 13> const & weights()
0776    {
0777       static constexpr std::array<T, 13> data = {
0778          1.23176053726715451e-01,
0779          1.22242442990310042e-01,
0780          1.19455763535784772e-01,
0781          1.14858259145711648e-01,
0782          1.08519624474263653e-01,
0783          1.00535949067050644e-01,
0784          9.10282619829636498e-02,
0785          8.01407003350010180e-02,
0786          6.80383338123569172e-02,
0787          5.49046959758351919e-02,
0788          4.09391567013063127e-02,
0789          2.63549866150321373e-02,
0790          1.13937985010262879e-02,
0791       };
0792       return data;
0793    }
0794 };
0795
0796 template <class T>
0797 class gauss_detail<T, 25, 2>
0798 {
0799 public:
0800    static std::array<T, 13> const & abscissa()
0801    {
0802       static constexpr std::array<T, 13> data = {
0803          0.00000000000000000000000000000000000e+00L,
0804          1.22864692610710396387359818808036806e-01L,
0805          2.43866883720988432045190362797451586e-01L,
0806          3.61172305809387837735821730127640667e-01L,
0807          4.73002731445714960522182115009192041e-01L,
0808          5.77662930241222967723689841612654067e-01L,
0809          6.73566368473468364485120633247622176e-01L,
0810          7.59259263037357630577282865204360976e-01L,
0811          8.33442628760834001421021108693569569e-01L,
0812          8.94991997878275368851042006782804954e-01L,
0813          9.42974571228974339414011169658470532e-01L,
0814          9.76663921459517511498315386479594068e-01L,
0815          9.95556969790498097908784946893901617e-01L,
0816       };
0817       return data;
0818    }
0819    static std::array<T, 13> const & weights()
0820    {
0821       static constexpr std::array<T, 13> data = {
0822          1.23176053726715451203902873079050142e-01L,
0823          1.22242442990310041688959518945851506e-01L,
0824          1.19455763535784772228178126512901047e-01L,
0825          1.14858259145711648339325545869555809e-01L,
0826          1.08519624474263653116093957050116619e-01L,
0827          1.00535949067050644202206890392685827e-01L,
0828          9.10282619829636498114972207028916534e-02L,
0829          8.01407003350010180132349596691113023e-02L,
0830          6.80383338123569172071871856567079686e-02L,
0831          5.49046959758351919259368915404733242e-02L,
0832          4.09391567013063126556234877116459537e-02L,
0833          2.63549866150321372619018152952991449e-02L,
0834          1.13937985010262879479029641132347736e-02L,
0835       };
0836       return data;
0837    }
0838 };
0839 #ifdef BOOST_HAS_FLOAT128
0840 template <class T>
0841 class gauss_detail<T, 25, 3>
0842 {
0843 public:
0844    static std::array<T, 13> const & abscissa()
0845    {
0846       static const std::array<T, 13> data = {
0847          0.00000000000000000000000000000000000e+00Q,
0848          1.22864692610710396387359818808036806e-01Q,
0849          2.43866883720988432045190362797451586e-01Q,
0850          3.61172305809387837735821730127640667e-01Q,
0851          4.73002731445714960522182115009192041e-01Q,
0852          5.77662930241222967723689841612654067e-01Q,
0853          6.73566368473468364485120633247622176e-01Q,
0854          7.59259263037357630577282865204360976e-01Q,
0855          8.33442628760834001421021108693569569e-01Q,
0856          8.94991997878275368851042006782804954e-01Q,
0857          9.42974571228974339414011169658470532e-01Q,
0858          9.76663921459517511498315386479594068e-01Q,
0859          9.95556969790498097908784946893901617e-01Q,
0860       };
0861       return data;
0862    }
0863    static std::array<T, 13> const & weights()
0864    {
0865       static const std::array<T, 13> data = {
0866          1.23176053726715451203902873079050142e-01Q,
0867          1.22242442990310041688959518945851506e-01Q,
0868          1.19455763535784772228178126512901047e-01Q,
0869          1.14858259145711648339325545869555809e-01Q,
0870          1.08519624474263653116093957050116619e-01Q,
0871          1.00535949067050644202206890392685827e-01Q,
0872          9.10282619829636498114972207028916534e-02Q,
0873          8.01407003350010180132349596691113023e-02Q,
0874          6.80383338123569172071871856567079686e-02Q,
0875          5.49046959758351919259368915404733242e-02Q,
0876          4.09391567013063126556234877116459537e-02Q,
0877          2.63549866150321372619018152952991449e-02Q,
0878          1.13937985010262879479029641132347736e-02Q,
0879       };
0880       return data;
0881    }
0882 };
0883 #endif
0884 template <class T>
0885 class gauss_detail<T, 25, 4>
0886 {
0887 public:
0888    static  std::array<T, 13> const & abscissa()
0889    {
0890       static  std::array<T, 13> data = {
0891          BOOST_MATH_HUGE_CONSTANT(T, 0, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00),
0892          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2286469261071039638735981880803680553220534604978373842389353789270883496885841582643884994633105537597765980412320e-01),
0893          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.4386688372098843204519036279745158640563315632598447642113565325038747278585595067977636776325034060327548499765742e-01),
0894          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.6117230580938783773582173012764066742207834704337506979457877784674538239569654860329531506093761400789294612122812e-01),
0895          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.7300273144571496052218211500919204133181773846162729090723082769560327584128603010315684778279363544192787010704498e-01),
0896          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.7766293024122296772368984161265406739573503929151825664548350776102301275263202227671659646579649084013116066120581e-01),
0897          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.7356636847346836448512063324762217588341672807274931705965696177828773684928421158196368568030932194044282149314388e-01),
0898          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.5925926303735763057728286520436097638752201889833412091838973544501862882026240760763679724185230331463919586229073e-01),
0899          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.3344262876083400142102110869356956946096411382352078602086471546171813247709012525322973947759168107133491065937347e-01),
0900          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.9499199787827536885104200678280495417455484975358390306170168295917151090119945137118600693039178162093726882638296e-01),
0901          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.4297457122897433941401116965847053190520157060899014192745249713729532254404926130890521815127348327109666786665572e-01),
0902          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.7666392145951751149831538647959406774537055531440674467098742731616386753588055389644670948300617866819865983054648e-01),
0903          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9555696979049809790878494689390161725756264940480817121080493113293348134372793448728802635294700756868258870429256e-01),
0904       };
0905       return data;
0906    }
0907    static  std::array<T, 13> const & weights()
0908    {
0909       static  std::array<T, 13> data = {
0910          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2317605372671545120390287307905014243823362751815166539135219731691200794926142128460112517504958377310054583945994e-01),
0911          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2224244299031004168895951894585150583505924756305904090758008223203896721918010243033540891078906637115620156845304e-01),
0912          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1945576353578477222817812651290104739017670141372642551958788133518409022018773502442869720975271321374348568426235e-01),
0913          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1485825914571164833932554586955580864093619166818014959151499003148279667112542256534429898558156273250513652351744e-01),
0914          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0851962447426365311609395705011661934007758798672201615649430734883929279360844269339768350029654172135832773427565e-01),
0915          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0053594906705064420220689039268582698846609452814190706986904199941294815904602968195565620373258211755226681206658e-01),
0916          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.1028261982963649811497220702891653380992558959334310970483768967017384678410526902484398142953718885872521590850372e-02),
0917          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.0140700335001018013234959669111302290225732853675893716201462973612828934801289559457377714225318048243957479325813e-02),
0918          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.8038333812356917207187185656707968554709494354636562615071226410003654051711473106651522969481873733098761760660898e-02),
0919          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.4904695975835191925936891540473324160109985553111349048508498244593774678436511895711924079433444763756746828817613e-02),
0920          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.0939156701306312655623487711645953660845783364104346504698414899297432880215512770478971055110424130123527015425511e-02),
0921          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.6354986615032137261901815295299144935963281703322468755366165783870934008879499371529821528172928890350362464605104e-02),
0922          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1393798501026287947902964113234773603320526292909696448948061116189891729766743355923677112945033505688431618009664e-02),
0923       };
0924       return data;
0925    }
0926 };
0927
0928 template <class T>
0929 class gauss_detail<T, 30, 0>
0930 {
0931 public:
0932    static std::array<T, 15> const & abscissa()
0933    {
0934       static constexpr std::array<T, 15> data = {
0935          5.147184256e-02f,
0936          1.538699136e-01f,
0937          2.546369262e-01f,
0938          3.527047255e-01f,
0939          4.470337695e-01f,
0940          5.366241481e-01f,
0941          6.205261830e-01f,
0942          6.978504948e-01f,
0943          7.677774321e-01f,
0944          8.295657624e-01f,
0945          8.825605358e-01f,
0946          9.262000474e-01f,
0947          9.600218650e-01f,
0948          9.836681233e-01f,
0949          9.968934841e-01f,
0950       };
0951       return data;
0952    }
0953    static std::array<T, 15> const & weights()
0954    {
0955       static constexpr std::array<T, 15> data = {
0956          1.028526529e-01f,
0957          1.017623897e-01f,
0958          9.959342059e-02f,
0959          9.636873717e-02f,
0960          9.212252224e-02f,
0961          8.689978720e-02f,
0962          8.075589523e-02f,
0963          7.375597474e-02f,
0964          6.597422988e-02f,
0965          5.749315622e-02f,
0966          4.840267283e-02f,
0967          3.879919257e-02f,
0968          2.878470788e-02f,
0969          1.846646831e-02f,
0970          7.968192496e-03f,
0971       };
0972       return data;
0973    }
0974 };
0975
0976 template <class T>
0977 class gauss_detail<T, 30, 1>
0978 {
0979 public:
0980    static std::array<T, 15> const & abscissa()
0981    {
0982       static constexpr std::array<T, 15> data = {
0983          5.14718425553176958e-02,
0984          1.53869913608583547e-01,
0985          2.54636926167889846e-01,
0986          3.52704725530878113e-01,
0987          4.47033769538089177e-01,
0988          5.36624148142019899e-01,
0989          6.20526182989242861e-01,
0990          6.97850494793315797e-01,
0991          7.67777432104826195e-01,
0992          8.29565762382768397e-01,
0993          8.82560535792052682e-01,
0994          9.26200047429274326e-01,
0995          9.60021864968307512e-01,
0996          9.83668123279747210e-01,
0997          9.96893484074649540e-01,
0998       };
0999       return data;
1000    }
1001    static std::array<T, 15> const & weights()
1002    {
1003       static constexpr std::array<T, 15> data = {
1004          1.02852652893558840e-01,
1005          1.01762389748405505e-01,
1006          9.95934205867952671e-02,
1007          9.63687371746442596e-02,
1008          9.21225222377861287e-02,
1009          8.68997872010829798e-02,
1010          8.07558952294202154e-02,
1011          7.37559747377052063e-02,
1012          6.59742298821804951e-02,
1013          5.74931562176190665e-02,
1014          4.84026728305940529e-02,
1015          3.87991925696270496e-02,
1016          2.87847078833233693e-02,
1017          1.84664683110909591e-02,
1018          7.96819249616660562e-03,
1019       };
1020       return data;
1021    }
1022 };
1023
1024 template <class T>
1025 class gauss_detail<T, 30, 2>
1026 {
1027 public:
1028    static std::array<T, 15> const & abscissa()
1029    {
1030       static constexpr std::array<T, 15> data = {
1031          5.14718425553176958330252131667225737e-02L,
1032          1.53869913608583546963794672743255920e-01L,
1033          2.54636926167889846439805129817805108e-01L,
1034          3.52704725530878113471037207089373861e-01L,
1035          4.47033769538089176780609900322854000e-01L,
1036          5.36624148142019899264169793311072794e-01L,
1037          6.20526182989242861140477556431189299e-01L,
1038          6.97850494793315796932292388026640068e-01L,
1039          7.67777432104826194917977340974503132e-01L,
1040          8.29565762382768397442898119732501916e-01L,
1041          8.82560535792052681543116462530225590e-01L,
1042          9.26200047429274325879324277080474004e-01L,
1043          9.60021864968307512216871025581797663e-01L,
1044          9.83668123279747209970032581605662802e-01L,
1045          9.96893484074649540271630050918695283e-01L,
1046       };
1047       return data;
1048    }
1049    static std::array<T, 15> const & weights()
1050    {
1051       static constexpr std::array<T, 15> data = {
1052          1.02852652893558840341285636705415044e-01L,
1053          1.01762389748405504596428952168554045e-01L,
1054          9.95934205867952670627802821035694765e-02L,
1055          9.63687371746442596394686263518098651e-02L,
1056          9.21225222377861287176327070876187672e-02L,
1057          8.68997872010829798023875307151257026e-02L,
1058          8.07558952294202153546949384605297309e-02L,
1059          7.37559747377052062682438500221907342e-02L,
1060          6.59742298821804951281285151159623612e-02L,
1061          5.74931562176190664817216894020561288e-02L,
1062          4.84026728305940529029381404228075178e-02L,
1063          3.87991925696270495968019364463476920e-02L,
1064          2.87847078833233693497191796112920436e-02L,
1065          1.84664683110909591423021319120472691e-02L,
1066          7.96819249616660561546588347467362245e-03L,
1067       };
1068       return data;
1069    }
1070 };
1071 #ifdef BOOST_HAS_FLOAT128
1072 template <class T>
1073 class gauss_detail<T, 30, 3>
1074 {
1075 public:
1076    static std::array<T, 15> const & abscissa()
1077    {
1078       static const std::array<T, 15> data = {
1079          5.14718425553176958330252131667225737e-02Q,
1080          1.53869913608583546963794672743255920e-01Q,
1081          2.54636926167889846439805129817805108e-01Q,
1082          3.52704725530878113471037207089373861e-01Q,
1083          4.47033769538089176780609900322854000e-01Q,
1084          5.36624148142019899264169793311072794e-01Q,
1085          6.20526182989242861140477556431189299e-01Q,
1086          6.97850494793315796932292388026640068e-01Q,
1087          7.67777432104826194917977340974503132e-01Q,
1088          8.29565762382768397442898119732501916e-01Q,
1089          8.82560535792052681543116462530225590e-01Q,
1090          9.26200047429274325879324277080474004e-01Q,
1091          9.60021864968307512216871025581797663e-01Q,
1092          9.83668123279747209970032581605662802e-01Q,
1093          9.96893484074649540271630050918695283e-01Q,
1094       };
1095       return data;
1096    }
1097    static std::array<T, 15> const & weights()
1098    {
1099       static const std::array<T, 15> data = {
1100          1.02852652893558840341285636705415044e-01Q,
1101          1.01762389748405504596428952168554045e-01Q,
1102          9.95934205867952670627802821035694765e-02Q,
1103          9.63687371746442596394686263518098651e-02Q,
1104          9.21225222377861287176327070876187672e-02Q,
1105          8.68997872010829798023875307151257026e-02Q,
1106          8.07558952294202153546949384605297309e-02Q,
1107          7.37559747377052062682438500221907342e-02Q,
1108          6.59742298821804951281285151159623612e-02Q,
1109          5.74931562176190664817216894020561288e-02Q,
1110          4.84026728305940529029381404228075178e-02Q,
1111          3.87991925696270495968019364463476920e-02Q,
1112          2.87847078833233693497191796112920436e-02Q,
1113          1.84664683110909591423021319120472691e-02Q,
1114          7.96819249616660561546588347467362245e-03Q,
1115       };
1116       return data;
1117    }
1118 };
1119 #endif
1120 template <class T>
1121 class gauss_detail<T, 30, 4>
1122 {
1123 public:
1124    static  std::array<T, 15> const & abscissa()
1125    {
1126       static  std::array<T, 15> data = {
1127          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.1471842555317695833025213166722573749141453666569564255160843987964755210427109055870090707285485841217089963590678e-02),
1128          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.5386991360858354696379467274325592041855197124433846171896298291578714851081610139692310651074078557990111754952062e-01),
1129          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.5463692616788984643980512981780510788278930330251842616428597508896353156907880290636628138423620257595521678255758e-01),
1130          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.5270472553087811347103720708937386065363100802142562659418446890026941623319107866436039675211352945165817827083104e-01),
1131          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.4703376953808917678060990032285400016240759386142440975447738172761535172858420700400688872124189834257262048739699e-01),
1132          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.3662414814201989926416979331107279416417800693029710545274348291201490861897837863114116009718990258091585830703557e-01),
1133          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.2052618298924286114047755643118929920736469282952813259505117012433531497488911774115258445532782106478789996137481e-01),
1134          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.9785049479331579693229238802664006838235380065395465637972284673997672124315996069538163644008904690545069439941341e-01),
1135          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.6777743210482619491797734097450313169488361723290845320649438736515857017299504505260960258623968420224697596501719e-01),
1136          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.2956576238276839744289811973250191643906869617034167880695298345365650658958163508295244350814016004371545455777732e-01),
1137          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.8256053579205268154311646253022559005668914714648423206832605312161626269519165572921583828573210485349058106849548e-01),
1138          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.2620004742927432587932427708047400408647453682532906091103713367942299565110232681677288015055886244486106298320068e-01),
1139          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.6002186496830751221687102558179766293035921740392339948566167242493995770706842922718944370380002378239172677454384e-01),
1140          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.8366812327974720997003258160566280194031785470971136351718001015114429536479104370207597166035471368057762560137209e-01),
1141          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9689348407464954027163005091869528334088203811775079010809429780238769521016374081588201955806171741257405095963817e-01),
1142       };
1143       return data;
1144    }
1145    static  std::array<T, 15> const & weights()
1146    {
1147       static  std::array<T, 15> data = {
1148          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0285265289355884034128563670541504386837555706492822258631898667601623865660942939262884632188870916503815852709086e-01),
1149          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0176238974840550459642895216855404463270628948712684086426094541964251360531767494547599781978391198881693385887696e-01),
1150          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9593420586795267062780282103569476529869263666704277221365146183946660389908809018092299289324184705373523229592037e-02),
1151          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.6368737174644259639468626351809865096406461430160245912994275732837534742003123724951247818104195363343093583583429e-02),
1152          BOOST_MATH_HUGE_CONSTANT(T, 0, 9.2122522237786128717632707087618767196913234418234107527675047001973047070094168298464052916811907158954949394100501e-02),
1153          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.6899787201082979802387530715125702576753328743545344012222129882153582254261494247955033509639105330215477601953921e-02),
1154          BOOST_MATH_HUGE_CONSTANT(T, 0, 8.0755895229420215354694938460529730875892803708439299890258593706051180567026345604212402769217808080749416147400962e-02),
1155          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.3755974737705206268243850022190734153770526037049438941269182374599399314635211710401352716638183270192254236882630e-02),
1156          BOOST_MATH_HUGE_CONSTANT(T, 0, 6.5974229882180495128128515115962361237442953656660378967031516042143672466094179365819913911598737439478205808271237e-02),
1157          BOOST_MATH_HUGE_CONSTANT(T, 0, 5.7493156217619066481721689402056128797120670721763134548715799003232147409954376925211999650950125355559974348279846e-02),
1158          BOOST_MATH_HUGE_CONSTANT(T, 0, 4.8402672830594052902938140422807517815271809197372736345191936791805425677102152797767439563562263454374645955072007e-02),
1159          BOOST_MATH_HUGE_CONSTANT(T, 0, 3.8799192569627049596801936446347692033200976766395352107732789705946970952769793919055026279035105656340228558382274e-02),
1160          BOOST_MATH_HUGE_CONSTANT(T, 0, 2.8784707883323369349719179611292043639588894546287496474180122608145988940013933101730206711484171554940392262251283e-02),
1161          BOOST_MATH_HUGE_CONSTANT(T, 0, 1.8466468311090959142302131912047269096206533968181403371298365514585599521307973654080519029675417955638095832046164e-02),
1162          BOOST_MATH_HUGE_CONSTANT(T, 0, 7.9681924961666056154658834746736224504806965871517212294851633569200384329013332941536616922861735209846506562158817e-03),
1163       };
1164       return data;
1165    }
1166 };
1167
1168 }
1169
1170 template <class Real, unsigned N, class Policy = boost::math::policies::policy<> >
1171 class gauss : public detail::gauss_detail<Real, N, detail::gauss_constant_category<Real>::value>
1172 {
1173    typedef detail::gauss_detail<Real, N, detail::gauss_constant_category<Real>::value> base;
1174 public:
1175
1176    template <class F>
1177    static auto integrate(F f, Real* pL1 = nullptr)->decltype(std::declval<F>()(std::declval<Real>()))
1178    {
1179      // In many math texts, K represents the field of real or complex numbers.
1180      // Too bad we can't put blackboard bold into C++ source!
1181       typedef decltype(f(Real(0))) K;
1182       static_assert(!std::is_integral<K>::value,
1183                    "The return type cannot be integral, it must be either a real or complex floating point type.");
1184       using std::abs;
1185       unsigned non_zero_start = 1;
1186       K result = Real(0);
1187       if (N & 1) {
1188          result = f(Real(0)) * base::weights()[0];
1189       }
1190       else {
1191          result = 0;
1192          non_zero_start = 0;
1193       }
1194       Real L1 = abs(result);
1195       for (unsigned i = non_zero_start; i < base::abscissa().size(); ++i)
1196       {
1197          K fp = f(base::abscissa()[i]);
1198          K fm = f(-base::abscissa()[i]);
1199          result += (fp + fm) * base::weights()[i];
1200          L1 += (abs(fp) + abs(fm)) *  base::weights()[i];
1201       }
1202       if (pL1)
1203          *pL1 = L1;
1204       return result;
1205    }
1206    template <class F>
1207    static auto integrate(F f, Real a, Real b, Real* pL1 = nullptr)->decltype(std::declval<F>()(std::declval<Real>()))
1208    {
1209       typedef decltype(f(a)) K;
1210       static const char* function = "boost::math::quadrature::gauss<%1%>::integrate(f, %1%, %1%)";
1211       if (!(boost::math::isnan)(a) && !(boost::math::isnan)(b))
1212       {
1213          // Infinite limits:
1214          Real min_inf = -tools::max_value<Real>();
1215          if ((a <= min_inf) && (b >= tools::max_value<Real>()))
1216          {
1217             auto u = [&](const Real& t)->K
1218             {
1219                Real t_sq = t*t;
1220                Real inv = 1 / (1 - t_sq);
1221                K res = f(t*inv)*(1 + t_sq)*inv*inv;
1222                return res;
1223             };
1224             return integrate(u, pL1);
1225          }
1226
1227          // Right limit is infinite:
1228          if ((boost::math::isfinite)(a) && (b >= tools::max_value<Real>()))
1229          {
1230             auto u = [&](const Real& t)->K
1231             {
1232                Real z = 1 / (t + 1);
1233                Real arg = 2 * z + a - 1;
1234                K res = f(arg)*z*z;
1235                return res;
1236             };
1237             K Q = Real(2) * integrate(u, pL1);
1238             if (pL1)
1239             {
1240                *pL1 *= 2;
1241             }
1242             return Q;
1243          }
1244
1245          if ((boost::math::isfinite)(b) && (a <= -tools::max_value<Real>()))
1246          {
1247             auto v = [&](const Real& t)->K
1248             {
1249                Real z = 1 / (t + 1);
1250                Real arg = 2 * z - 1;
1251                K res = f(b - arg) * z * z;
1252                return res;
1253             };
1254             K Q = Real(2) * integrate(v, pL1);
1255             if (pL1)
1256             {
1257                *pL1 *= 2;
1258             }
1259             return Q;
1260          }
1261
1262          if ((boost::math::isfinite)(a) && (boost::math::isfinite)(b))
1263          {
1264             if (a == b)
1265             {
1266                return K(0);
1267             }
1268             if (b < a)
1269             {
1270                return -integrate(f, b, a, pL1);
1271             }
1272             Real avg = (a + b)*constants::half<Real>();
1273             Real scale = (b - a)*constants::half<Real>();
1274
1275             auto u = [&](Real z)->K
1276             {
1277                return f(avg + scale*z);
1278             };
1279             K Q = scale*integrate(u, pL1);
1280
1281             if (pL1)
1282             {
1283                *pL1 *= scale;
1284             }
1285             return Q;
1286          }
1287       }
1288       return static_cast<K>(policies::raise_domain_error(function, "The domain of integration is not sensible; please check the bounds.", a, Policy()));
1289    }
1290 };
1291
1292 } // namespace quadrature
1293 } // namespace math
1294 } // namespace boost
1295
1296 #ifdef _MSC_VER
1297 #pragma warning(pop)
1298 #endif
1299
1300 #endif // BOOST_MATH_QUADRATURE_GAUSS_HPP