]>
Commit | Line | Data |
---|---|---|
b32b8144 FG |
1 | // Copyright John Maddock 2015. |
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_QUADRATURE_GAUSS_HPP | |
7 | #define BOOST_MATH_QUADRATURE_GAUSS_HPP | |
8 | ||
9 | #ifdef _MSC_VER | |
10 | #pragma once | |
11 | #endif | |
12 | ||
13 | #include <vector> | |
14 | #include <boost/math/special_functions/legendre.hpp> | |
15 | #include <boost/math/constants/constants.hpp> | |
16 | ||
17 | #ifdef _MSC_VER | |
18 | #pragma warning(push) | |
19 | #pragma warning(disable:4127) | |
20 | #endif | |
21 | ||
22 | namespace boost { namespace math{ namespace quadrature{ namespace detail{ | |
23 | ||
24 | template <class T> | |
25 | struct gauss_constant_category | |
26 | { | |
27 | static const unsigned value = | |
28 | (std::numeric_limits<T>::is_specialized == 0) ? 999 : | |
29 | (std::numeric_limits<T>::radix == 2) ? | |
30 | ( | |
31 | (std::numeric_limits<T>::digits <= std::numeric_limits<float>::digits) && boost::is_convertible<float, T>::value ? 0 : | |
32 | (std::numeric_limits<T>::digits <= std::numeric_limits<double>::digits) && boost::is_convertible<double, T>::value ? 1 : | |
33 | (std::numeric_limits<T>::digits <= std::numeric_limits<long double>::digits) && boost::is_convertible<long double, T>::value ? 2 : | |
34 | #ifdef BOOST_HAS_FLOAT128 | |
35 | (std::numeric_limits<T>::digits <= 113) && boost::is_constructible<__float128, T>::value ? 3 : | |
36 | #endif | |
37 | (std::numeric_limits<T>::digits10 <= 110) ? 4 : 999 | |
38 | ) : (std::numeric_limits<T>::digits10 <= 110) ? 4 : 999; | |
39 | }; | |
40 | ||
41 | #ifndef BOOST_MATH_GAUSS_NO_COMPUTE_ON_DEMAND | |
42 | ||
43 | template <class Real, unsigned N, unsigned Category> | |
44 | class gauss_detail | |
45 | { | |
46 | static std::vector<Real> calculate_weights() | |
47 | { | |
48 | std::vector<Real> result(abscissa().size(), 0); | |
49 | for (unsigned i = 0; i < abscissa().size(); ++i) | |
50 | { | |
51 | Real x = abscissa()[i]; | |
52 | Real p = boost::math::legendre_p_prime(N, x); | |
53 | result[i] = 2 / ((1 - x * x) * p * p); | |
54 | } | |
55 | return result; | |
56 | } | |
57 | public: | |
58 | static const std::vector<Real>& abscissa() | |
59 | { | |
60 | static std::vector<Real> data = boost::math::legendre_p_zeros<Real>(N); | |
61 | return data; | |
62 | } | |
63 | static const std::vector<Real>& weights() | |
64 | { | |
65 | static std::vector<Real> data = calculate_weights(); | |
66 | return data; | |
67 | } | |
68 | }; | |
69 | ||
70 | #else | |
71 | ||
72 | template <class Real, unsigned N, unsigned Category> | |
73 | class gauss_detail; | |
74 | ||
75 | #endif | |
76 | ||
77 | template <class T> | |
78 | class gauss_detail<T, 7, 0> | |
79 | { | |
80 | public: | |
81 | static std::array<T, 4> const & abscissa() | |
82 | { | |
83 | static const std::array<T, 4> data = { | |
84 | 0.000000000e+00f, | |
85 | 4.058451514e-01f, | |
86 | 7.415311856e-01f, | |
87 | 9.491079123e-01f, | |
88 | }; | |
89 | return data; | |
90 | } | |
91 | static std::array<T, 4> const & weights() | |
92 | { | |
93 | static const std::array<T, 4> data = { | |
94 | 4.179591837e-01f, | |
95 | 3.818300505e-01f, | |
96 | 2.797053915e-01f, | |
97 | 1.294849662e-01f, | |
98 | }; | |
99 | return data; | |
100 | } | |
101 | }; | |
102 | ||
103 | template <class T> | |
104 | class gauss_detail<T, 7, 1> | |
105 | { | |
106 | public: | |
107 | static std::array<T, 4> const & abscissa() | |
108 | { | |
109 | static const std::array<T, 4> data = { | |
110 | 0.00000000000000000e+00, | |
111 | 4.05845151377397167e-01, | |
112 | 7.41531185599394440e-01, | |
113 | 9.49107912342758525e-01, | |
114 | }; | |
115 | return data; | |
116 | } | |
117 | static std::array<T, 4> const & weights() | |
118 | { | |
119 | static const std::array<T, 4> data = { | |
120 | 4.17959183673469388e-01, | |
121 | 3.81830050505118945e-01, | |
122 | 2.79705391489276668e-01, | |
123 | 1.29484966168869693e-01, | |
124 | }; | |
125 | return data; | |
126 | } | |
127 | }; | |
128 | ||
129 | template <class T> | |
130 | class gauss_detail<T, 7, 2> | |
131 | { | |
132 | public: | |
133 | static std::array<T, 4> const & abscissa() | |
134 | { | |
135 | static const std::array<T, 4> data = { | |
136 | 0.00000000000000000000000000000000000e+00L, | |
137 | 4.05845151377397166906606412076961463e-01L, | |
138 | 7.41531185599394439863864773280788407e-01L, | |
139 | 9.49107912342758524526189684047851262e-01L, | |
140 | }; | |
141 | return data; | |
142 | } | |
143 | static std::array<T, 4> const & weights() | |
144 | { | |
145 | static const std::array<T, 4> data = { | |
146 | 4.17959183673469387755102040816326531e-01L, | |
147 | 3.81830050505118944950369775488975134e-01L, | |
148 | 2.79705391489276667901467771423779582e-01L, | |
149 | 1.29484966168869693270611432679082018e-01L, | |
150 | }; | |
151 | return data; | |
152 | } | |
153 | }; | |
154 | #ifdef BOOST_HAS_FLOAT128 | |
155 | template <class T> | |
156 | class gauss_detail<T, 7, 3> | |
157 | { | |
158 | public: | |
159 | static std::array<T, 4> const & abscissa() | |
160 | { | |
161 | static const std::array<T, 4> data = { | |
162 | 0.00000000000000000000000000000000000e+00Q, | |
163 | 4.05845151377397166906606412076961463e-01Q, | |
164 | 7.41531185599394439863864773280788407e-01Q, | |
165 | 9.49107912342758524526189684047851262e-01Q, | |
166 | }; | |
167 | return data; | |
168 | } | |
169 | static std::array<T, 4> const & weights() | |
170 | { | |
171 | static const std::array<T, 4> data = { | |
172 | 4.17959183673469387755102040816326531e-01Q, | |
173 | 3.81830050505118944950369775488975134e-01Q, | |
174 | 2.79705391489276667901467771423779582e-01Q, | |
175 | 1.29484966168869693270611432679082018e-01Q, | |
176 | }; | |
177 | return data; | |
178 | } | |
179 | }; | |
180 | #endif | |
181 | template <class T> | |
182 | class gauss_detail<T, 7, 4> | |
183 | { | |
184 | public: | |
185 | static std::array<T, 4> const & abscissa() | |
186 | { | |
187 | static std::array<T, 4> data = { | |
188 | BOOST_MATH_HUGE_CONSTANT(T, 0, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), | |
189 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.0584515137739716690660641207696146334738201409937012638704325179466381322612565532831268972774658776528675866604802e-01), | |
190 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.4153118559939443986386477328078840707414764714139026011995535196742987467218051379282683236686324705969251809311201e-01), | |
191 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.4910791234275852452618968404785126240077093767061778354876910391306333035484014080573077002792572414430073966699522e-01), | |
192 | }; | |
193 | return data; | |
194 | } | |
195 | static std::array<T, 4> const & weights() | |
196 | { | |
197 | static std::array<T, 4> data = { | |
198 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.1795918367346938775510204081632653061224489795918367346938775510204081632653061224489795918367346938775510204081633e-01), | |
199 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.8183005050511894495036977548897513387836508353386273475108345103070554643412970834868465934404480145031467176458536e-01), | |
200 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.7970539148927666790146777142377958248692506522659876453701403269361881043056267681324094290119761876632337521337205e-01), | |
201 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2948496616886969327061143267908201832858740225994666397720863872465523497204230871562541816292084508948440200163443e-01), | |
202 | }; | |
203 | return data; | |
204 | } | |
205 | }; | |
206 | ||
207 | template <class T> | |
208 | class gauss_detail<T, 10, 0> | |
209 | { | |
210 | public: | |
211 | static std::array<T, 5> const & abscissa() | |
212 | { | |
213 | static const std::array<T, 5> data = { | |
214 | 1.488743390e-01f, | |
215 | 4.333953941e-01f, | |
216 | 6.794095683e-01f, | |
217 | 8.650633667e-01f, | |
218 | 9.739065285e-01f, | |
219 | }; | |
220 | return data; | |
221 | } | |
222 | static std::array<T, 5> const & weights() | |
223 | { | |
224 | static const std::array<T, 5> data = { | |
225 | 2.955242247e-01f, | |
226 | 2.692667193e-01f, | |
227 | 2.190863625e-01f, | |
228 | 1.494513492e-01f, | |
229 | 6.667134431e-02f, | |
230 | }; | |
231 | return data; | |
232 | } | |
233 | }; | |
234 | ||
235 | template <class T> | |
236 | class gauss_detail<T, 10, 1> | |
237 | { | |
238 | public: | |
239 | static std::array<T, 5> const & abscissa() | |
240 | { | |
241 | static const std::array<T, 5> data = { | |
242 | 1.48874338981631211e-01, | |
243 | 4.33395394129247191e-01, | |
244 | 6.79409568299024406e-01, | |
245 | 8.65063366688984511e-01, | |
246 | 9.73906528517171720e-01, | |
247 | }; | |
248 | return data; | |
249 | } | |
250 | static std::array<T, 5> const & weights() | |
251 | { | |
252 | static const std::array<T, 5> data = { | |
253 | 2.95524224714752870e-01, | |
254 | 2.69266719309996355e-01, | |
255 | 2.19086362515982044e-01, | |
256 | 1.49451349150580593e-01, | |
257 | 6.66713443086881376e-02, | |
258 | }; | |
259 | return data; | |
260 | } | |
261 | }; | |
262 | ||
263 | template <class T> | |
264 | class gauss_detail<T, 10, 2> | |
265 | { | |
266 | public: | |
267 | static std::array<T, 5> const & abscissa() | |
268 | { | |
269 | static const std::array<T, 5> data = { | |
270 | 1.48874338981631210884826001129719985e-01L, | |
271 | 4.33395394129247190799265943165784162e-01L, | |
272 | 6.79409568299024406234327365114873576e-01L, | |
273 | 8.65063366688984510732096688423493049e-01L, | |
274 | 9.73906528517171720077964012084452053e-01L, | |
275 | }; | |
276 | return data; | |
277 | } | |
278 | static std::array<T, 5> const & weights() | |
279 | { | |
280 | static const std::array<T, 5> data = { | |
281 | 2.95524224714752870173892994651338329e-01L, | |
282 | 2.69266719309996355091226921569469353e-01L, | |
283 | 2.19086362515982043995534934228163192e-01L, | |
284 | 1.49451349150580593145776339657697332e-01L, | |
285 | 6.66713443086881375935688098933317929e-02L, | |
286 | }; | |
287 | return data; | |
288 | } | |
289 | }; | |
290 | #ifdef BOOST_HAS_FLOAT128 | |
291 | template <class T> | |
292 | class gauss_detail<T, 10, 3> | |
293 | { | |
294 | public: | |
295 | static std::array<T, 5> const & abscissa() | |
296 | { | |
297 | static const std::array<T, 5> data = { | |
298 | 1.48874338981631210884826001129719985e-01Q, | |
299 | 4.33395394129247190799265943165784162e-01Q, | |
300 | 6.79409568299024406234327365114873576e-01Q, | |
301 | 8.65063366688984510732096688423493049e-01Q, | |
302 | 9.73906528517171720077964012084452053e-01Q, | |
303 | }; | |
304 | return data; | |
305 | } | |
306 | static std::array<T, 5> const & weights() | |
307 | { | |
308 | static const std::array<T, 5> data = { | |
309 | 2.95524224714752870173892994651338329e-01Q, | |
310 | 2.69266719309996355091226921569469353e-01Q, | |
311 | 2.19086362515982043995534934228163192e-01Q, | |
312 | 1.49451349150580593145776339657697332e-01Q, | |
313 | 6.66713443086881375935688098933317929e-02Q, | |
314 | }; | |
315 | return data; | |
316 | } | |
317 | }; | |
318 | #endif | |
319 | template <class T> | |
320 | class gauss_detail<T, 10, 4> | |
321 | { | |
322 | public: | |
323 | static std::array<T, 5> const & abscissa() | |
324 | { | |
325 | static std::array<T, 5> data = { | |
326 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4887433898163121088482600112971998461756485942069169570798925351590361735566852137117762979946369123003116080525534e-01), | |
327 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.3339539412924719079926594316578416220007183765624649650270151314376698907770350122510275795011772122368293504099894e-01), | |
328 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.7940956829902440623432736511487357576929471183480946766481718895255857539507492461507857357048037949983390204739932e-01), | |
329 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.6506336668898451073209668842349304852754301496533045252195973184537475513805556135679072894604577069440463108641177e-01), | |
330 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.7390652851717172007796401208445205342826994669238211923121206669659520323463615962572356495626855625823304251877421e-01), | |
331 | }; | |
332 | return data; | |
333 | } | |
334 | static std::array<T, 5> const & weights() | |
335 | { | |
336 | static std::array<T, 5> data = { | |
337 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.9552422471475287017389299465133832942104671702685360135430802975599593821715232927035659579375421672271716440125256e-01), | |
338 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.6926671930999635509122692156946935285975993846088379580056327624215343231917927676422663670925276075559581145036870e-01), | |
339 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.1908636251598204399553493422816319245877187052267708988095654363519991065295128124268399317720219278659121687281289e-01), | |
340 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4945134915058059314577633965769733240255663966942736783547726875323865472663001094594726463473195191400575256104544e-01), | |
341 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.6671344308688137593568809893331792857864834320158145128694881613412064084087101776785509685058877821090054714520419e-02), | |
342 | }; | |
343 | return data; | |
344 | } | |
345 | }; | |
346 | ||
347 | template <class T> | |
348 | class gauss_detail<T, 15, 0> | |
349 | { | |
350 | public: | |
351 | static std::array<T, 8> const & abscissa() | |
352 | { | |
353 | static const std::array<T, 8> data = { | |
354 | 0.000000000e+00f, | |
355 | 2.011940940e-01f, | |
356 | 3.941513471e-01f, | |
357 | 5.709721726e-01f, | |
358 | 7.244177314e-01f, | |
359 | 8.482065834e-01f, | |
360 | 9.372733924e-01f, | |
361 | 9.879925180e-01f, | |
362 | }; | |
363 | return data; | |
364 | } | |
365 | static std::array<T, 8> const & weights() | |
366 | { | |
367 | static const std::array<T, 8> data = { | |
368 | 2.025782419e-01f, | |
369 | 1.984314853e-01f, | |
370 | 1.861610000e-01f, | |
371 | 1.662692058e-01f, | |
372 | 1.395706779e-01f, | |
373 | 1.071592205e-01f, | |
374 | 7.036604749e-02f, | |
375 | 3.075324200e-02f, | |
376 | }; | |
377 | return data; | |
378 | } | |
379 | }; | |
380 | ||
381 | template <class T> | |
382 | class gauss_detail<T, 15, 1> | |
383 | { | |
384 | public: | |
385 | static std::array<T, 8> const & abscissa() | |
386 | { | |
387 | static const std::array<T, 8> data = { | |
388 | 0.00000000000000000e+00, | |
389 | 2.01194093997434522e-01, | |
390 | 3.94151347077563370e-01, | |
391 | 5.70972172608538848e-01, | |
392 | 7.24417731360170047e-01, | |
393 | 8.48206583410427216e-01, | |
394 | 9.37273392400705904e-01, | |
395 | 9.87992518020485428e-01, | |
396 | }; | |
397 | return data; | |
398 | } | |
399 | static std::array<T, 8> const & weights() | |
400 | { | |
401 | static const std::array<T, 8> data = { | |
402 | 2.02578241925561273e-01, | |
403 | 1.98431485327111576e-01, | |
404 | 1.86161000015562211e-01, | |
405 | 1.66269205816993934e-01, | |
406 | 1.39570677926154314e-01, | |
407 | 1.07159220467171935e-01, | |
408 | 7.03660474881081247e-02, | |
409 | 3.07532419961172684e-02, | |
410 | }; | |
411 | return data; | |
412 | } | |
413 | }; | |
414 | ||
415 | template <class T> | |
416 | class gauss_detail<T, 15, 2> | |
417 | { | |
418 | public: | |
419 | static std::array<T, 8> const & abscissa() | |
420 | { | |
421 | static const std::array<T, 8> data = { | |
422 | 0.00000000000000000000000000000000000e+00L, | |
423 | 2.01194093997434522300628303394596208e-01L, | |
424 | 3.94151347077563369897207370981045468e-01L, | |
425 | 5.70972172608538847537226737253910641e-01L, | |
426 | 7.24417731360170047416186054613938010e-01L, | |
427 | 8.48206583410427216200648320774216851e-01L, | |
428 | 9.37273392400705904307758947710209471e-01L, | |
429 | 9.87992518020485428489565718586612581e-01L, | |
430 | }; | |
431 | return data; | |
432 | } | |
433 | static std::array<T, 8> const & weights() | |
434 | { | |
435 | static const std::array<T, 8> data = { | |
436 | 2.02578241925561272880620199967519315e-01L, | |
437 | 1.98431485327111576456118326443839325e-01L, | |
438 | 1.86161000015562211026800561866422825e-01L, | |
439 | 1.66269205816993933553200860481208811e-01L, | |
440 | 1.39570677926154314447804794511028323e-01L, | |
441 | 1.07159220467171935011869546685869303e-01L, | |
442 | 7.03660474881081247092674164506673385e-02L, | |
443 | 3.07532419961172683546283935772044177e-02L, | |
444 | }; | |
445 | return data; | |
446 | } | |
447 | }; | |
448 | #ifdef BOOST_HAS_FLOAT128 | |
449 | template <class T> | |
450 | class gauss_detail<T, 15, 3> | |
451 | { | |
452 | public: | |
453 | static std::array<T, 8> const & abscissa() | |
454 | { | |
455 | static const std::array<T, 8> data = { | |
456 | 0.00000000000000000000000000000000000e+00Q, | |
457 | 2.01194093997434522300628303394596208e-01Q, | |
458 | 3.94151347077563369897207370981045468e-01Q, | |
459 | 5.70972172608538847537226737253910641e-01Q, | |
460 | 7.24417731360170047416186054613938010e-01Q, | |
461 | 8.48206583410427216200648320774216851e-01Q, | |
462 | 9.37273392400705904307758947710209471e-01Q, | |
463 | 9.87992518020485428489565718586612581e-01Q, | |
464 | }; | |
465 | return data; | |
466 | } | |
467 | static std::array<T, 8> const & weights() | |
468 | { | |
469 | static const std::array<T, 8> data = { | |
470 | 2.02578241925561272880620199967519315e-01Q, | |
471 | 1.98431485327111576456118326443839325e-01Q, | |
472 | 1.86161000015562211026800561866422825e-01Q, | |
473 | 1.66269205816993933553200860481208811e-01Q, | |
474 | 1.39570677926154314447804794511028323e-01Q, | |
475 | 1.07159220467171935011869546685869303e-01Q, | |
476 | 7.03660474881081247092674164506673385e-02Q, | |
477 | 3.07532419961172683546283935772044177e-02Q, | |
478 | }; | |
479 | return data; | |
480 | } | |
481 | }; | |
482 | #endif | |
483 | template <class T> | |
484 | class gauss_detail<T, 15, 4> | |
485 | { | |
486 | public: | |
487 | static std::array<T, 8> const & abscissa() | |
488 | { | |
489 | static std::array<T, 8> data = { | |
490 | BOOST_MATH_HUGE_CONSTANT(T, 0, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), | |
491 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.0119409399743452230062830339459620781283645446263767961594972460994823900302018760183625806752105908967902257386509e-01), | |
492 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.9415134707756336989720737098104546836275277615869825503116534395160895778696141797549711416165976202589352169635648e-01), | |
493 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.7097217260853884753722673725391064123838639628274960485326541705419537986975857948341462856982614477912646497026257e-01), | |
494 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.2441773136017004741618605461393800963089929458410256355142342070412378167792521899610109760313432626923598549381925e-01), | |
495 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.4820658341042721620064832077421685136625617473699263409572755876067507517414548519760771975082148085090373835713340e-01), | |
496 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.3727339240070590430775894771020947124399627351530445790136307635020297379704552795054758617426808659746824044603157e-01), | |
497 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.8799251802048542848956571858661258114697281712376148999999751558738843736901942471272205036831914497667516843990079e-01), | |
498 | }; | |
499 | return data; | |
500 | } | |
501 | static std::array<T, 8> const & weights() | |
502 | { | |
503 | static std::array<T, 8> data = { | |
504 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.0257824192556127288062019996751931483866215800947735679670411605143539875474607409339344071278803213535148267082999e-01), | |
505 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.9843148532711157645611832644383932481869255995754199348473792792912479753343426813331499916481782320766020854889310e-01), | |
506 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.8616100001556221102680056186642282450622601227792840281549572731001325550269916061894976888609932360539977709001384e-01), | |
507 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.6626920581699393355320086048120881113090018009841290732186519056355356321227851771070517429241553621484461540657185e-01), | |
508 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.3957067792615431444780479451102832252085027531551124320239112863108844454190781168076825736357133363814908889327664e-01), | |
509 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0715922046717193501186954668586930341554371575810198068702238912187799485231579972568585713760862404439808767837506e-01), | |
510 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.0366047488108124709267416450667338466708032754330719825907292914387055512874237044840452066693939219355489858595041e-02), | |
511 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.0753241996117268354628393577204417721748144833434074264228285504237189467117168039038770732399404002516991188859473e-02), | |
512 | }; | |
513 | return data; | |
514 | } | |
515 | }; | |
516 | ||
517 | template <class T> | |
518 | class gauss_detail<T, 20, 0> | |
519 | { | |
520 | public: | |
521 | static std::array<T, 10> const & abscissa() | |
522 | { | |
523 | static const std::array<T, 10> data = { | |
524 | 7.652652113e-02f, | |
525 | 2.277858511e-01f, | |
526 | 3.737060887e-01f, | |
527 | 5.108670020e-01f, | |
528 | 6.360536807e-01f, | |
529 | 7.463319065e-01f, | |
530 | 8.391169718e-01f, | |
531 | 9.122344283e-01f, | |
532 | 9.639719273e-01f, | |
533 | 9.931285992e-01f, | |
534 | }; | |
535 | return data; | |
536 | } | |
537 | static std::array<T, 10> const & weights() | |
538 | { | |
539 | static const std::array<T, 10> data = { | |
540 | 1.527533871e-01f, | |
541 | 1.491729865e-01f, | |
542 | 1.420961093e-01f, | |
543 | 1.316886384e-01f, | |
544 | 1.181945320e-01f, | |
545 | 1.019301198e-01f, | |
546 | 8.327674158e-02f, | |
547 | 6.267204833e-02f, | |
548 | 4.060142980e-02f, | |
549 | 1.761400714e-02f, | |
550 | }; | |
551 | return data; | |
552 | } | |
553 | }; | |
554 | ||
555 | template <class T> | |
556 | class gauss_detail<T, 20, 1> | |
557 | { | |
558 | public: | |
559 | static std::array<T, 10> const & abscissa() | |
560 | { | |
561 | static const std::array<T, 10> data = { | |
562 | 7.65265211334973338e-02, | |
563 | 2.27785851141645078e-01, | |
564 | 3.73706088715419561e-01, | |
565 | 5.10867001950827098e-01, | |
566 | 6.36053680726515025e-01, | |
567 | 7.46331906460150793e-01, | |
568 | 8.39116971822218823e-01, | |
569 | 9.12234428251325906e-01, | |
570 | 9.63971927277913791e-01, | |
571 | 9.93128599185094925e-01, | |
572 | }; | |
573 | return data; | |
574 | } | |
575 | static std::array<T, 10> const & weights() | |
576 | { | |
577 | static const std::array<T, 10> data = { | |
578 | 1.52753387130725851e-01, | |
579 | 1.49172986472603747e-01, | |
580 | 1.42096109318382051e-01, | |
581 | 1.31688638449176627e-01, | |
582 | 1.18194531961518417e-01, | |
583 | 1.01930119817240435e-01, | |
584 | 8.32767415767047487e-02, | |
585 | 6.26720483341090636e-02, | |
586 | 4.06014298003869413e-02, | |
587 | 1.76140071391521183e-02, | |
588 | }; | |
589 | return data; | |
590 | } | |
591 | }; | |
592 | ||
593 | template <class T> | |
594 | class gauss_detail<T, 20, 2> | |
595 | { | |
596 | public: | |
597 | static std::array<T, 10> const & abscissa() | |
598 | { | |
599 | static const std::array<T, 10> data = { | |
600 | 7.65265211334973337546404093988382110e-02L, | |
601 | 2.27785851141645078080496195368574625e-01L, | |
602 | 3.73706088715419560672548177024927237e-01L, | |
603 | 5.10867001950827098004364050955250998e-01L, | |
604 | 6.36053680726515025452836696226285937e-01L, | |
605 | 7.46331906460150792614305070355641590e-01L, | |
606 | 8.39116971822218823394529061701520685e-01L, | |
607 | 9.12234428251325905867752441203298113e-01L, | |
608 | 9.63971927277913791267666131197277222e-01L, | |
609 | 9.93128599185094924786122388471320278e-01L, | |
610 | }; | |
611 | return data; | |
612 | } | |
613 | static std::array<T, 10> const & weights() | |
614 | { | |
615 | static const std::array<T, 10> data = { | |
616 | 1.52753387130725850698084331955097593e-01L, | |
617 | 1.49172986472603746787828737001969437e-01L, | |
618 | 1.42096109318382051329298325067164933e-01L, | |
619 | 1.31688638449176626898494499748163135e-01L, | |
620 | 1.18194531961518417312377377711382287e-01L, | |
621 | 1.01930119817240435036750135480349876e-01L, | |
622 | 8.32767415767047487247581432220462061e-02L, | |
623 | 6.26720483341090635695065351870416064e-02L, | |
624 | 4.06014298003869413310399522749321099e-02L, | |
625 | 1.76140071391521183118619623518528164e-02L, | |
626 | }; | |
627 | return data; | |
628 | } | |
629 | }; | |
630 | #ifdef BOOST_HAS_FLOAT128 | |
631 | template <class T> | |
632 | class gauss_detail<T, 20, 3> | |
633 | { | |
634 | public: | |
635 | static std::array<T, 10> const & abscissa() | |
636 | { | |
637 | static const std::array<T, 10> data = { | |
638 | 7.65265211334973337546404093988382110e-02Q, | |
639 | 2.27785851141645078080496195368574625e-01Q, | |
640 | 3.73706088715419560672548177024927237e-01Q, | |
641 | 5.10867001950827098004364050955250998e-01Q, | |
642 | 6.36053680726515025452836696226285937e-01Q, | |
643 | 7.46331906460150792614305070355641590e-01Q, | |
644 | 8.39116971822218823394529061701520685e-01Q, | |
645 | 9.12234428251325905867752441203298113e-01Q, | |
646 | 9.63971927277913791267666131197277222e-01Q, | |
647 | 9.93128599185094924786122388471320278e-01Q, | |
648 | }; | |
649 | return data; | |
650 | } | |
651 | static std::array<T, 10> const & weights() | |
652 | { | |
653 | static const std::array<T, 10> data = { | |
654 | 1.52753387130725850698084331955097593e-01Q, | |
655 | 1.49172986472603746787828737001969437e-01Q, | |
656 | 1.42096109318382051329298325067164933e-01Q, | |
657 | 1.31688638449176626898494499748163135e-01Q, | |
658 | 1.18194531961518417312377377711382287e-01Q, | |
659 | 1.01930119817240435036750135480349876e-01Q, | |
660 | 8.32767415767047487247581432220462061e-02Q, | |
661 | 6.26720483341090635695065351870416064e-02Q, | |
662 | 4.06014298003869413310399522749321099e-02Q, | |
663 | 1.76140071391521183118619623518528164e-02Q, | |
664 | }; | |
665 | return data; | |
666 | } | |
667 | }; | |
668 | #endif | |
669 | template <class T> | |
670 | class gauss_detail<T, 20, 4> | |
671 | { | |
672 | public: | |
673 | static std::array<T, 10> const & abscissa() | |
674 | { | |
675 | static std::array<T, 10> data = { | |
676 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.6526521133497333754640409398838211004796266813497500804795244384256342048336978241545114181556215606998505646364133e-02), | |
677 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.2778585114164507808049619536857462474308893768292747231463573920717134186355582779495212519096870803177373131560430e-01), | |
678 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.7370608871541956067254817702492723739574632170568271182794861351564576437305952789589568363453337894476772208852815e-01), | |
679 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.1086700195082709800436405095525099842549132920242683347234861989473497039076572814403168305086777919832943068843526e-01), | |
680 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.3605368072651502545283669622628593674338911679936846393944662254654126258543013255870319549576130658211710937772596e-01), | |
681 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.4633190646015079261430507035564159031073067956917644413954590606853535503815506468110411362064752061238490065167656e-01), | |
682 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.3911697182221882339452906170152068532962936506563737325249272553286109399932480991922934056595764922060422035306914e-01), | |
683 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.1223442825132590586775244120329811304918479742369177479588221915807089120871907893644472619292138737876039175464603e-01), | |
684 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.6397192727791379126766613119727722191206032780618885606353759389204158078438305698001812525596471563131043491596423e-01), | |
685 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9312859918509492478612238847132027822264713090165589614818413121798471762775378083944940249657220927472894034724419e-01), | |
686 | }; | |
687 | return data; | |
688 | } | |
689 | static std::array<T, 10> const & weights() | |
690 | { | |
691 | static std::array<T, 10> data = { | |
692 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.5275338713072585069808433195509759349194864511237859727470104981759745316273778153557248783650390593544001842813788e-01), | |
693 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4917298647260374678782873700196943669267990408136831649621121780984442259558678069396132603521048105170913854567338e-01), | |
694 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.4209610931838205132929832506716493303451541339202030333736708298382808749793436761694922428320058260133068573666201e-01), | |
695 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.3168863844917662689849449974816313491611051114698352699643649370885435642948093314355797518397262924510598005463625e-01), | |
696 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1819453196151841731237737771138228700504121954896877544688995202017474835051151630572868782581901744606267543092317e-01), | |
697 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0193011981724043503675013548034987616669165602339255626197161619685232202539434647534931576947985821375859035525483e-01), | |
698 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.3276741576704748724758143222046206100177828583163290744882060785693082894079419471375190843790839349096116111932764e-02), | |
699 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.2672048334109063569506535187041606351601076578436364099584345437974811033665678644563766056832203512603253399592073e-02), | |
700 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.0601429800386941331039952274932109879090639989951536817606854561832296750987328295538920623044384976189825709675075e-02), | |
701 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.7614007139152118311861962351852816362143105543336732524349326677348419259621847817403105542146097668703716227512570e-02), | |
702 | }; | |
703 | return data; | |
704 | } | |
705 | }; | |
706 | ||
707 | template <class T> | |
708 | class gauss_detail<T, 25, 0> | |
709 | { | |
710 | public: | |
711 | static std::array<T, 13> const & abscissa() | |
712 | { | |
713 | static const std::array<T, 13> data = { | |
714 | 0.000000000e+00f, | |
715 | 1.228646926e-01f, | |
716 | 2.438668837e-01f, | |
717 | 3.611723058e-01f, | |
718 | 4.730027314e-01f, | |
719 | 5.776629302e-01f, | |
720 | 6.735663685e-01f, | |
721 | 7.592592630e-01f, | |
722 | 8.334426288e-01f, | |
723 | 8.949919979e-01f, | |
724 | 9.429745712e-01f, | |
725 | 9.766639215e-01f, | |
726 | 9.955569698e-01f, | |
727 | }; | |
728 | return data; | |
729 | } | |
730 | static std::array<T, 13> const & weights() | |
731 | { | |
732 | static const std::array<T, 13> data = { | |
733 | 1.231760537e-01f, | |
734 | 1.222424430e-01f, | |
735 | 1.194557635e-01f, | |
736 | 1.148582591e-01f, | |
737 | 1.085196245e-01f, | |
738 | 1.005359491e-01f, | |
739 | 9.102826198e-02f, | |
740 | 8.014070034e-02f, | |
741 | 6.803833381e-02f, | |
742 | 5.490469598e-02f, | |
743 | 4.093915670e-02f, | |
744 | 2.635498662e-02f, | |
745 | 1.139379850e-02f, | |
746 | }; | |
747 | return data; | |
748 | } | |
749 | }; | |
750 | ||
751 | template <class T> | |
752 | class gauss_detail<T, 25, 1> | |
753 | { | |
754 | public: | |
755 | static std::array<T, 13> const & abscissa() | |
756 | { | |
757 | static const std::array<T, 13> data = { | |
758 | 0.00000000000000000e+00, | |
759 | 1.22864692610710396e-01, | |
760 | 2.43866883720988432e-01, | |
761 | 3.61172305809387838e-01, | |
762 | 4.73002731445714961e-01, | |
763 | 5.77662930241222968e-01, | |
764 | 6.73566368473468364e-01, | |
765 | 7.59259263037357631e-01, | |
766 | 8.33442628760834001e-01, | |
767 | 8.94991997878275369e-01, | |
768 | 9.42974571228974339e-01, | |
769 | 9.76663921459517511e-01, | |
770 | 9.95556969790498098e-01, | |
771 | }; | |
772 | return data; | |
773 | } | |
774 | static std::array<T, 13> const & weights() | |
775 | { | |
776 | static const std::array<T, 13> data = { | |
777 | 1.23176053726715451e-01, | |
778 | 1.22242442990310042e-01, | |
779 | 1.19455763535784772e-01, | |
780 | 1.14858259145711648e-01, | |
781 | 1.08519624474263653e-01, | |
782 | 1.00535949067050644e-01, | |
783 | 9.10282619829636498e-02, | |
784 | 8.01407003350010180e-02, | |
785 | 6.80383338123569172e-02, | |
786 | 5.49046959758351919e-02, | |
787 | 4.09391567013063127e-02, | |
788 | 2.63549866150321373e-02, | |
789 | 1.13937985010262879e-02, | |
790 | }; | |
791 | return data; | |
792 | } | |
793 | }; | |
794 | ||
795 | template <class T> | |
796 | class gauss_detail<T, 25, 2> | |
797 | { | |
798 | public: | |
799 | static std::array<T, 13> const & abscissa() | |
800 | { | |
801 | static const std::array<T, 13> data = { | |
802 | 0.00000000000000000000000000000000000e+00L, | |
803 | 1.22864692610710396387359818808036806e-01L, | |
804 | 2.43866883720988432045190362797451586e-01L, | |
805 | 3.61172305809387837735821730127640667e-01L, | |
806 | 4.73002731445714960522182115009192041e-01L, | |
807 | 5.77662930241222967723689841612654067e-01L, | |
808 | 6.73566368473468364485120633247622176e-01L, | |
809 | 7.59259263037357630577282865204360976e-01L, | |
810 | 8.33442628760834001421021108693569569e-01L, | |
811 | 8.94991997878275368851042006782804954e-01L, | |
812 | 9.42974571228974339414011169658470532e-01L, | |
813 | 9.76663921459517511498315386479594068e-01L, | |
814 | 9.95556969790498097908784946893901617e-01L, | |
815 | }; | |
816 | return data; | |
817 | } | |
818 | static std::array<T, 13> const & weights() | |
819 | { | |
820 | static const std::array<T, 13> data = { | |
821 | 1.23176053726715451203902873079050142e-01L, | |
822 | 1.22242442990310041688959518945851506e-01L, | |
823 | 1.19455763535784772228178126512901047e-01L, | |
824 | 1.14858259145711648339325545869555809e-01L, | |
825 | 1.08519624474263653116093957050116619e-01L, | |
826 | 1.00535949067050644202206890392685827e-01L, | |
827 | 9.10282619829636498114972207028916534e-02L, | |
828 | 8.01407003350010180132349596691113023e-02L, | |
829 | 6.80383338123569172071871856567079686e-02L, | |
830 | 5.49046959758351919259368915404733242e-02L, | |
831 | 4.09391567013063126556234877116459537e-02L, | |
832 | 2.63549866150321372619018152952991449e-02L, | |
833 | 1.13937985010262879479029641132347736e-02L, | |
834 | }; | |
835 | return data; | |
836 | } | |
837 | }; | |
838 | #ifdef BOOST_HAS_FLOAT128 | |
839 | template <class T> | |
840 | class gauss_detail<T, 25, 3> | |
841 | { | |
842 | public: | |
843 | static std::array<T, 13> const & abscissa() | |
844 | { | |
845 | static const std::array<T, 13> data = { | |
846 | 0.00000000000000000000000000000000000e+00Q, | |
847 | 1.22864692610710396387359818808036806e-01Q, | |
848 | 2.43866883720988432045190362797451586e-01Q, | |
849 | 3.61172305809387837735821730127640667e-01Q, | |
850 | 4.73002731445714960522182115009192041e-01Q, | |
851 | 5.77662930241222967723689841612654067e-01Q, | |
852 | 6.73566368473468364485120633247622176e-01Q, | |
853 | 7.59259263037357630577282865204360976e-01Q, | |
854 | 8.33442628760834001421021108693569569e-01Q, | |
855 | 8.94991997878275368851042006782804954e-01Q, | |
856 | 9.42974571228974339414011169658470532e-01Q, | |
857 | 9.76663921459517511498315386479594068e-01Q, | |
858 | 9.95556969790498097908784946893901617e-01Q, | |
859 | }; | |
860 | return data; | |
861 | } | |
862 | static std::array<T, 13> const & weights() | |
863 | { | |
864 | static const std::array<T, 13> data = { | |
865 | 1.23176053726715451203902873079050142e-01Q, | |
866 | 1.22242442990310041688959518945851506e-01Q, | |
867 | 1.19455763535784772228178126512901047e-01Q, | |
868 | 1.14858259145711648339325545869555809e-01Q, | |
869 | 1.08519624474263653116093957050116619e-01Q, | |
870 | 1.00535949067050644202206890392685827e-01Q, | |
871 | 9.10282619829636498114972207028916534e-02Q, | |
872 | 8.01407003350010180132349596691113023e-02Q, | |
873 | 6.80383338123569172071871856567079686e-02Q, | |
874 | 5.49046959758351919259368915404733242e-02Q, | |
875 | 4.09391567013063126556234877116459537e-02Q, | |
876 | 2.63549866150321372619018152952991449e-02Q, | |
877 | 1.13937985010262879479029641132347736e-02Q, | |
878 | }; | |
879 | return data; | |
880 | } | |
881 | }; | |
882 | #endif | |
883 | template <class T> | |
884 | class gauss_detail<T, 25, 4> | |
885 | { | |
886 | public: | |
887 | static std::array<T, 13> const & abscissa() | |
888 | { | |
889 | static std::array<T, 13> data = { | |
890 | BOOST_MATH_HUGE_CONSTANT(T, 0, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+00), | |
891 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2286469261071039638735981880803680553220534604978373842389353789270883496885841582643884994633105537597765980412320e-01), | |
892 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.4386688372098843204519036279745158640563315632598447642113565325038747278585595067977636776325034060327548499765742e-01), | |
893 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.6117230580938783773582173012764066742207834704337506979457877784674538239569654860329531506093761400789294612122812e-01), | |
894 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.7300273144571496052218211500919204133181773846162729090723082769560327584128603010315684778279363544192787010704498e-01), | |
895 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.7766293024122296772368984161265406739573503929151825664548350776102301275263202227671659646579649084013116066120581e-01), | |
896 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.7356636847346836448512063324762217588341672807274931705965696177828773684928421158196368568030932194044282149314388e-01), | |
897 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.5925926303735763057728286520436097638752201889833412091838973544501862882026240760763679724185230331463919586229073e-01), | |
898 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.3344262876083400142102110869356956946096411382352078602086471546171813247709012525322973947759168107133491065937347e-01), | |
899 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.9499199787827536885104200678280495417455484975358390306170168295917151090119945137118600693039178162093726882638296e-01), | |
900 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.4297457122897433941401116965847053190520157060899014192745249713729532254404926130890521815127348327109666786665572e-01), | |
901 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.7666392145951751149831538647959406774537055531440674467098742731616386753588055389644670948300617866819865983054648e-01), | |
902 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9555696979049809790878494689390161725756264940480817121080493113293348134372793448728802635294700756868258870429256e-01), | |
903 | }; | |
904 | return data; | |
905 | } | |
906 | static std::array<T, 13> const & weights() | |
907 | { | |
908 | static std::array<T, 13> data = { | |
909 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2317605372671545120390287307905014243823362751815166539135219731691200794926142128460112517504958377310054583945994e-01), | |
910 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.2224244299031004168895951894585150583505924756305904090758008223203896721918010243033540891078906637115620156845304e-01), | |
911 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1945576353578477222817812651290104739017670141372642551958788133518409022018773502442869720975271321374348568426235e-01), | |
912 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1485825914571164833932554586955580864093619166818014959151499003148279667112542256534429898558156273250513652351744e-01), | |
913 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0851962447426365311609395705011661934007758798672201615649430734883929279360844269339768350029654172135832773427565e-01), | |
914 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0053594906705064420220689039268582698846609452814190706986904199941294815904602968195565620373258211755226681206658e-01), | |
915 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.1028261982963649811497220702891653380992558959334310970483768967017384678410526902484398142953718885872521590850372e-02), | |
916 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.0140700335001018013234959669111302290225732853675893716201462973612828934801289559457377714225318048243957479325813e-02), | |
917 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.8038333812356917207187185656707968554709494354636562615071226410003654051711473106651522969481873733098761760660898e-02), | |
918 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.4904695975835191925936891540473324160109985553111349048508498244593774678436511895711924079433444763756746828817613e-02), | |
919 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.0939156701306312655623487711645953660845783364104346504698414899297432880215512770478971055110424130123527015425511e-02), | |
920 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.6354986615032137261901815295299144935963281703322468755366165783870934008879499371529821528172928890350362464605104e-02), | |
921 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.1393798501026287947902964113234773603320526292909696448948061116189891729766743355923677112945033505688431618009664e-02), | |
922 | }; | |
923 | return data; | |
924 | } | |
925 | }; | |
926 | ||
927 | template <class T> | |
928 | class gauss_detail<T, 30, 0> | |
929 | { | |
930 | public: | |
931 | static std::array<T, 15> const & abscissa() | |
932 | { | |
933 | static const std::array<T, 15> data = { | |
934 | 5.147184256e-02f, | |
935 | 1.538699136e-01f, | |
936 | 2.546369262e-01f, | |
937 | 3.527047255e-01f, | |
938 | 4.470337695e-01f, | |
939 | 5.366241481e-01f, | |
940 | 6.205261830e-01f, | |
941 | 6.978504948e-01f, | |
942 | 7.677774321e-01f, | |
943 | 8.295657624e-01f, | |
944 | 8.825605358e-01f, | |
945 | 9.262000474e-01f, | |
946 | 9.600218650e-01f, | |
947 | 9.836681233e-01f, | |
948 | 9.968934841e-01f, | |
949 | }; | |
950 | return data; | |
951 | } | |
952 | static std::array<T, 15> const & weights() | |
953 | { | |
954 | static const std::array<T, 15> data = { | |
955 | 1.028526529e-01f, | |
956 | 1.017623897e-01f, | |
957 | 9.959342059e-02f, | |
958 | 9.636873717e-02f, | |
959 | 9.212252224e-02f, | |
960 | 8.689978720e-02f, | |
961 | 8.075589523e-02f, | |
962 | 7.375597474e-02f, | |
963 | 6.597422988e-02f, | |
964 | 5.749315622e-02f, | |
965 | 4.840267283e-02f, | |
966 | 3.879919257e-02f, | |
967 | 2.878470788e-02f, | |
968 | 1.846646831e-02f, | |
969 | 7.968192496e-03f, | |
970 | }; | |
971 | return data; | |
972 | } | |
973 | }; | |
974 | ||
975 | template <class T> | |
976 | class gauss_detail<T, 30, 1> | |
977 | { | |
978 | public: | |
979 | static std::array<T, 15> const & abscissa() | |
980 | { | |
981 | static const std::array<T, 15> data = { | |
982 | 5.14718425553176958e-02, | |
983 | 1.53869913608583547e-01, | |
984 | 2.54636926167889846e-01, | |
985 | 3.52704725530878113e-01, | |
986 | 4.47033769538089177e-01, | |
987 | 5.36624148142019899e-01, | |
988 | 6.20526182989242861e-01, | |
989 | 6.97850494793315797e-01, | |
990 | 7.67777432104826195e-01, | |
991 | 8.29565762382768397e-01, | |
992 | 8.82560535792052682e-01, | |
993 | 9.26200047429274326e-01, | |
994 | 9.60021864968307512e-01, | |
995 | 9.83668123279747210e-01, | |
996 | 9.96893484074649540e-01, | |
997 | }; | |
998 | return data; | |
999 | } | |
1000 | static std::array<T, 15> const & weights() | |
1001 | { | |
1002 | static const std::array<T, 15> data = { | |
1003 | 1.02852652893558840e-01, | |
1004 | 1.01762389748405505e-01, | |
1005 | 9.95934205867952671e-02, | |
1006 | 9.63687371746442596e-02, | |
1007 | 9.21225222377861287e-02, | |
1008 | 8.68997872010829798e-02, | |
1009 | 8.07558952294202154e-02, | |
1010 | 7.37559747377052063e-02, | |
1011 | 6.59742298821804951e-02, | |
1012 | 5.74931562176190665e-02, | |
1013 | 4.84026728305940529e-02, | |
1014 | 3.87991925696270496e-02, | |
1015 | 2.87847078833233693e-02, | |
1016 | 1.84664683110909591e-02, | |
1017 | 7.96819249616660562e-03, | |
1018 | }; | |
1019 | return data; | |
1020 | } | |
1021 | }; | |
1022 | ||
1023 | template <class T> | |
1024 | class gauss_detail<T, 30, 2> | |
1025 | { | |
1026 | public: | |
1027 | static std::array<T, 15> const & abscissa() | |
1028 | { | |
1029 | static const std::array<T, 15> data = { | |
1030 | 5.14718425553176958330252131667225737e-02L, | |
1031 | 1.53869913608583546963794672743255920e-01L, | |
1032 | 2.54636926167889846439805129817805108e-01L, | |
1033 | 3.52704725530878113471037207089373861e-01L, | |
1034 | 4.47033769538089176780609900322854000e-01L, | |
1035 | 5.36624148142019899264169793311072794e-01L, | |
1036 | 6.20526182989242861140477556431189299e-01L, | |
1037 | 6.97850494793315796932292388026640068e-01L, | |
1038 | 7.67777432104826194917977340974503132e-01L, | |
1039 | 8.29565762382768397442898119732501916e-01L, | |
1040 | 8.82560535792052681543116462530225590e-01L, | |
1041 | 9.26200047429274325879324277080474004e-01L, | |
1042 | 9.60021864968307512216871025581797663e-01L, | |
1043 | 9.83668123279747209970032581605662802e-01L, | |
1044 | 9.96893484074649540271630050918695283e-01L, | |
1045 | }; | |
1046 | return data; | |
1047 | } | |
1048 | static std::array<T, 15> const & weights() | |
1049 | { | |
1050 | static const std::array<T, 15> data = { | |
1051 | 1.02852652893558840341285636705415044e-01L, | |
1052 | 1.01762389748405504596428952168554045e-01L, | |
1053 | 9.95934205867952670627802821035694765e-02L, | |
1054 | 9.63687371746442596394686263518098651e-02L, | |
1055 | 9.21225222377861287176327070876187672e-02L, | |
1056 | 8.68997872010829798023875307151257026e-02L, | |
1057 | 8.07558952294202153546949384605297309e-02L, | |
1058 | 7.37559747377052062682438500221907342e-02L, | |
1059 | 6.59742298821804951281285151159623612e-02L, | |
1060 | 5.74931562176190664817216894020561288e-02L, | |
1061 | 4.84026728305940529029381404228075178e-02L, | |
1062 | 3.87991925696270495968019364463476920e-02L, | |
1063 | 2.87847078833233693497191796112920436e-02L, | |
1064 | 1.84664683110909591423021319120472691e-02L, | |
1065 | 7.96819249616660561546588347467362245e-03L, | |
1066 | }; | |
1067 | return data; | |
1068 | } | |
1069 | }; | |
1070 | #ifdef BOOST_HAS_FLOAT128 | |
1071 | template <class T> | |
1072 | class gauss_detail<T, 30, 3> | |
1073 | { | |
1074 | public: | |
1075 | static std::array<T, 15> const & abscissa() | |
1076 | { | |
1077 | static const std::array<T, 15> data = { | |
1078 | 5.14718425553176958330252131667225737e-02Q, | |
1079 | 1.53869913608583546963794672743255920e-01Q, | |
1080 | 2.54636926167889846439805129817805108e-01Q, | |
1081 | 3.52704725530878113471037207089373861e-01Q, | |
1082 | 4.47033769538089176780609900322854000e-01Q, | |
1083 | 5.36624148142019899264169793311072794e-01Q, | |
1084 | 6.20526182989242861140477556431189299e-01Q, | |
1085 | 6.97850494793315796932292388026640068e-01Q, | |
1086 | 7.67777432104826194917977340974503132e-01Q, | |
1087 | 8.29565762382768397442898119732501916e-01Q, | |
1088 | 8.82560535792052681543116462530225590e-01Q, | |
1089 | 9.26200047429274325879324277080474004e-01Q, | |
1090 | 9.60021864968307512216871025581797663e-01Q, | |
1091 | 9.83668123279747209970032581605662802e-01Q, | |
1092 | 9.96893484074649540271630050918695283e-01Q, | |
1093 | }; | |
1094 | return data; | |
1095 | } | |
1096 | static std::array<T, 15> const & weights() | |
1097 | { | |
1098 | static const std::array<T, 15> data = { | |
1099 | 1.02852652893558840341285636705415044e-01Q, | |
1100 | 1.01762389748405504596428952168554045e-01Q, | |
1101 | 9.95934205867952670627802821035694765e-02Q, | |
1102 | 9.63687371746442596394686263518098651e-02Q, | |
1103 | 9.21225222377861287176327070876187672e-02Q, | |
1104 | 8.68997872010829798023875307151257026e-02Q, | |
1105 | 8.07558952294202153546949384605297309e-02Q, | |
1106 | 7.37559747377052062682438500221907342e-02Q, | |
1107 | 6.59742298821804951281285151159623612e-02Q, | |
1108 | 5.74931562176190664817216894020561288e-02Q, | |
1109 | 4.84026728305940529029381404228075178e-02Q, | |
1110 | 3.87991925696270495968019364463476920e-02Q, | |
1111 | 2.87847078833233693497191796112920436e-02Q, | |
1112 | 1.84664683110909591423021319120472691e-02Q, | |
1113 | 7.96819249616660561546588347467362245e-03Q, | |
1114 | }; | |
1115 | return data; | |
1116 | } | |
1117 | }; | |
1118 | #endif | |
1119 | template <class T> | |
1120 | class gauss_detail<T, 30, 4> | |
1121 | { | |
1122 | public: | |
1123 | static std::array<T, 15> const & abscissa() | |
1124 | { | |
1125 | static std::array<T, 15> data = { | |
1126 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.1471842555317695833025213166722573749141453666569564255160843987964755210427109055870090707285485841217089963590678e-02), | |
1127 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.5386991360858354696379467274325592041855197124433846171896298291578714851081610139692310651074078557990111754952062e-01), | |
1128 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.5463692616788984643980512981780510788278930330251842616428597508896353156907880290636628138423620257595521678255758e-01), | |
1129 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.5270472553087811347103720708937386065363100802142562659418446890026941623319107866436039675211352945165817827083104e-01), | |
1130 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.4703376953808917678060990032285400016240759386142440975447738172761535172858420700400688872124189834257262048739699e-01), | |
1131 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.3662414814201989926416979331107279416417800693029710545274348291201490861897837863114116009718990258091585830703557e-01), | |
1132 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.2052618298924286114047755643118929920736469282952813259505117012433531497488911774115258445532782106478789996137481e-01), | |
1133 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.9785049479331579693229238802664006838235380065395465637972284673997672124315996069538163644008904690545069439941341e-01), | |
1134 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.6777743210482619491797734097450313169488361723290845320649438736515857017299504505260960258623968420224697596501719e-01), | |
1135 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.2956576238276839744289811973250191643906869617034167880695298345365650658958163508295244350814016004371545455777732e-01), | |
1136 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.8256053579205268154311646253022559005668914714648423206832605312161626269519165572921583828573210485349058106849548e-01), | |
1137 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.2620004742927432587932427708047400408647453682532906091103713367942299565110232681677288015055886244486106298320068e-01), | |
1138 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.6002186496830751221687102558179766293035921740392339948566167242493995770706842922718944370380002378239172677454384e-01), | |
1139 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.8366812327974720997003258160566280194031785470971136351718001015114429536479104370207597166035471368057762560137209e-01), | |
1140 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9689348407464954027163005091869528334088203811775079010809429780238769521016374081588201955806171741257405095963817e-01), | |
1141 | }; | |
1142 | return data; | |
1143 | } | |
1144 | static std::array<T, 15> const & weights() | |
1145 | { | |
1146 | static std::array<T, 15> data = { | |
1147 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0285265289355884034128563670541504386837555706492822258631898667601623865660942939262884632188870916503815852709086e-01), | |
1148 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.0176238974840550459642895216855404463270628948712684086426094541964251360531767494547599781978391198881693385887696e-01), | |
1149 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.9593420586795267062780282103569476529869263666704277221365146183946660389908809018092299289324184705373523229592037e-02), | |
1150 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.6368737174644259639468626351809865096406461430160245912994275732837534742003123724951247818104195363343093583583429e-02), | |
1151 | BOOST_MATH_HUGE_CONSTANT(T, 0, 9.2122522237786128717632707087618767196913234418234107527675047001973047070094168298464052916811907158954949394100501e-02), | |
1152 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.6899787201082979802387530715125702576753328743545344012222129882153582254261494247955033509639105330215477601953921e-02), | |
1153 | BOOST_MATH_HUGE_CONSTANT(T, 0, 8.0755895229420215354694938460529730875892803708439299890258593706051180567026345604212402769217808080749416147400962e-02), | |
1154 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.3755974737705206268243850022190734153770526037049438941269182374599399314635211710401352716638183270192254236882630e-02), | |
1155 | BOOST_MATH_HUGE_CONSTANT(T, 0, 6.5974229882180495128128515115962361237442953656660378967031516042143672466094179365819913911598737439478205808271237e-02), | |
1156 | BOOST_MATH_HUGE_CONSTANT(T, 0, 5.7493156217619066481721689402056128797120670721763134548715799003232147409954376925211999650950125355559974348279846e-02), | |
1157 | BOOST_MATH_HUGE_CONSTANT(T, 0, 4.8402672830594052902938140422807517815271809197372736345191936791805425677102152797767439563562263454374645955072007e-02), | |
1158 | BOOST_MATH_HUGE_CONSTANT(T, 0, 3.8799192569627049596801936446347692033200976766395352107732789705946970952769793919055026279035105656340228558382274e-02), | |
1159 | BOOST_MATH_HUGE_CONSTANT(T, 0, 2.8784707883323369349719179611292043639588894546287496474180122608145988940013933101730206711484171554940392262251283e-02), | |
1160 | BOOST_MATH_HUGE_CONSTANT(T, 0, 1.8466468311090959142302131912047269096206533968181403371298365514585599521307973654080519029675417955638095832046164e-02), | |
1161 | BOOST_MATH_HUGE_CONSTANT(T, 0, 7.9681924961666056154658834746736224504806965871517212294851633569200384329013332941536616922861735209846506562158817e-03), | |
1162 | }; | |
1163 | return data; | |
1164 | } | |
1165 | }; | |
1166 | ||
1167 | } | |
1168 | ||
1169 | template <class Real, unsigned N, class Policy = boost::math::policies::policy<> > | |
1170 | class gauss : public detail::gauss_detail<Real, N, detail::gauss_constant_category<Real>::value> | |
1171 | { | |
1172 | typedef detail::gauss_detail<Real, N, detail::gauss_constant_category<Real>::value> base; | |
1173 | public: | |
1174 | typedef Real value_type; | |
1175 | ||
1176 | template <class F> | |
1177 | static value_type integrate(F f, Real* pL1 = nullptr) | |
1178 | { | |
1179 | using std::fabs; | |
1180 | unsigned non_zero_start = 1; | |
1181 | value_type result = 0; | |
1182 | if (N & 1) | |
1183 | result = f(value_type(0)) * base::weights()[0]; | |
1184 | else | |
1185 | non_zero_start = 0; | |
1186 | value_type L1 = fabs(result); | |
1187 | for (unsigned i = non_zero_start; i < base::abscissa().size(); ++i) | |
1188 | { | |
1189 | value_type fp = f(base::abscissa()[i]); | |
1190 | value_type fm = f(-base::abscissa()[i]); | |
1191 | result += (fp + fm) * base::weights()[i]; | |
1192 | L1 += (fabs(fp) + fabs(fm)) * base::weights()[i]; | |
1193 | } | |
1194 | if (pL1) | |
1195 | *pL1 = L1; | |
1196 | return result; | |
1197 | } | |
1198 | template <class F> | |
1199 | static value_type integrate(F f, Real a, Real b, Real* pL1 = nullptr) | |
1200 | { | |
1201 | static const char* function = "boost::math::quadrature::gauss<%1%>::integrate(f, %1%, %1%)"; | |
1202 | if (!(boost::math::isnan)(a) && !(boost::math::isnan)(b)) | |
1203 | { | |
1204 | // Infinite limits: | |
1205 | if ((a <= -tools::max_value<Real>()) && (b >= tools::max_value<Real>())) | |
1206 | { | |
1207 | auto u = [&](const Real& t)->Real | |
1208 | { | |
1209 | Real t_sq = t*t; | |
1210 | Real inv = 1 / (1 - t_sq); | |
1211 | return f(t*inv)*(1 + t_sq)*inv*inv; | |
1212 | }; | |
1213 | return integrate(u, pL1); | |
1214 | } | |
1215 | ||
1216 | // Right limit is infinite: | |
1217 | if ((boost::math::isfinite)(a) && (b >= tools::max_value<Real>())) | |
1218 | { | |
1219 | auto u = [&](const Real& t)->Real | |
1220 | { | |
1221 | Real z = 1 / (t + 1); | |
1222 | Real arg = 2 * z + a - 1; | |
1223 | return f(arg)*z*z; | |
1224 | }; | |
1225 | Real Q = 2 * integrate(u, pL1); | |
1226 | if (pL1) | |
1227 | { | |
1228 | *pL1 *= 2; | |
1229 | } | |
1230 | return Q; | |
1231 | } | |
1232 | ||
1233 | if ((boost::math::isfinite)(b) && (a <= -tools::max_value<Real>())) | |
1234 | { | |
1235 | auto v = [&](const Real& t)->Real | |
1236 | { | |
1237 | Real z = 1 / (t + 1); | |
1238 | Real arg = 2 * z - 1; | |
1239 | return f(b - arg) * z * z; | |
1240 | }; | |
1241 | Real Q = 2 * integrate(v, pL1); | |
1242 | if (pL1) | |
1243 | { | |
1244 | *pL1 *= 2; | |
1245 | } | |
1246 | return Q; | |
1247 | } | |
1248 | ||
1249 | if ((boost::math::isfinite)(a) && (boost::math::isfinite)(b)) | |
1250 | { | |
1251 | if (b <= a) | |
1252 | { | |
1253 | return policies::raise_domain_error(function, "Arguments to integrate are in wrong order; integration over [a,b] must have b > a.", a, Policy()); | |
1254 | } | |
1255 | Real avg = (a + b)*constants::half<Real>(); | |
1256 | Real scale = (b - a)*constants::half<Real>(); | |
1257 | ||
1258 | auto u = [&](Real z)->Real | |
1259 | { | |
1260 | return f(avg + scale*z); | |
1261 | }; | |
1262 | Real Q = scale*integrate(u, pL1); | |
1263 | ||
1264 | if (pL1) | |
1265 | { | |
1266 | *pL1 *= scale; | |
1267 | } | |
1268 | return Q; | |
1269 | } | |
1270 | } | |
1271 | return policies::raise_domain_error(function, "The domain of integration is not sensible; please check the bounds.", a, Policy()); | |
1272 | } | |
1273 | }; | |
1274 | ||
1275 | } // namespace quadrature | |
1276 | } // namespace math | |
1277 | } // namespace boost | |
1278 | ||
1279 | #ifdef _MSC_VER | |
1280 | #pragma warning(pop) | |
1281 | #endif | |
1282 | ||
1283 | #endif // BOOST_MATH_QUADRATURE_GAUSS_HPP | |
1284 |