4 use pm_quadpack,
only:
getQuadGK, ninf, pinf
13 real(RK) :: integral, abserr, intAbsFunc, smoothness, truth
15 type(display_type) :: disp
19 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
20 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
21 call disp%show(
"! Gauss-Kronrod quadrature over a finite interval.")
22 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
23 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
27 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
28 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the Beta distribution.")
29 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
35 call disp%show(
"integral = getQuadGK(getBetaPDF, 0._RK, +1._RK, GK15, abserr, intAbsFunc, smoothness)")
36 integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK15, abserr, intAbsFunc, smoothness)
37 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
38 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
42 call disp%show(
"integral = getQuadGK(getBetaPDF, 0._RK, +1._RK, GK21, abserr, intAbsFunc, smoothness)")
43 integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK21, abserr, intAbsFunc, smoothness)
44 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
45 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
49 call disp%show(
"integral = getQuadGK(getBetaPDF, 0._RK, +1._RK, GK41, abserr, intAbsFunc, smoothness)")
50 integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK41, abserr, intAbsFunc, smoothness)
51 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
52 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
56 call disp%show(
"integral = getQuadGK(getBetaPDF, 0._RK, +1._RK, GK51, abserr, intAbsFunc, smoothness)")
57 integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK51, abserr, intAbsFunc, smoothness)
58 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
59 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
63 call disp%show(
"integral = getQuadGK(getBetaPDF, 0._RK, +1._RK, GK61, abserr, intAbsFunc, smoothness)")
64 integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK61, abserr, intAbsFunc, smoothness)
65 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
66 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
70 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
71 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the Beta distribution for non-default node counts.")
72 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
76 integer(IK) ,
parameter :: MAX_NPG
= 30_IK
78 real(RK) :: nodeK(MAX_NPG
+1), weightK(MAX_NPG
+1), weightG((MAX_NPG
+1)
/2)
79 do npg
= 1_IK, MAX_NPG
81 call disp%show(
"npg ! The number of points in the Gauss-Legendre quadrature rule.")
83 call disp%show(
"call setNodeWeightGK(nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2)) ! Compute the Gauss-Kronrod nodes and weights")
84 call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
85 call disp%show(
"integral = getQuadGK(getBetaPDF, 0._RK, +1._RK, nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2), abserr, intAbsFunc, smoothness) ! Compute the (2*npg + 1)-points Gauss-Kronrod quadrature.")
86 integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
87 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
88 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
94 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
95 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
96 call disp%show(
"! Gauss-Kronrod quadrature over a positive semi-infinite interval.")
97 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
98 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
102 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
103 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the LogNormal distribution on the semi-infinite range `(0,+infinity)`.")
104 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
110 call disp%show(
"integral = getQuadGK(getLogNormPDF, 0._RK, pinf, GK15, abserr, intAbsFunc, smoothness)")
111 integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK15, abserr, intAbsFunc, smoothness)
112 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
113 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
117 call disp%show(
"integral = getQuadGK(getLogNormPDF, 0._RK, pinf, GK21, abserr, intAbsFunc, smoothness)")
118 integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK21, abserr, intAbsFunc, smoothness)
119 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
120 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
124 call disp%show(
"integral = getQuadGK(getLogNormPDF, 0._RK, pinf, GK41, abserr, intAbsFunc, smoothness)")
125 integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK41, abserr, intAbsFunc, smoothness)
126 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
127 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
131 call disp%show(
"integral = getQuadGK(getLogNormPDF, 0._RK, pinf, GK51, abserr, intAbsFunc, smoothness)")
132 integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK51, abserr, intAbsFunc, smoothness)
133 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
134 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
138 call disp%show(
"integral = getQuadGK(getLogNormPDF, 0._RK, pinf, GK61, abserr, intAbsFunc, smoothness)")
139 integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK61, abserr, intAbsFunc, smoothness)
140 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
141 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
145 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
146 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the LogNormal distribution for non-default node counts.")
147 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
151 integer(IK) ,
parameter :: MAX_NPG
= 30_IK
153 real(RK) :: nodeK(MAX_NPG
+1), weightK(MAX_NPG
+1), weightG((MAX_NPG
+1)
/2)
154 do npg
= 1_IK, MAX_NPG
156 call disp%show(
"npg ! The number of points in the Gauss-Legendre quadrature rule.")
158 call disp%show(
"call setNodeWeightGK(nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2)) ! Compute the Gauss-Kronrod nodes and weights")
159 call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
160 call disp%show(
"integral = getQuadGK(getLogNormPDF, 0._RK, pinf, nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2), abserr, intAbsFunc, smoothness) ! Compute the (2*npg + 1)-points Gauss-Kronrod quadrature.")
161 integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
162 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
163 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
169 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
170 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
171 call disp%show(
"! Gauss-Kronrod quadrature over a negative semi-infinite interval.")
172 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
173 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
177 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
178 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the Exponential distribution on the semi-infinite range `(-infinity,0)`.")
179 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
185 call disp%show(
"integral = getQuadGK(getNegExpPDF, ninf, 0._RK, GK15, abserr, intAbsFunc, smoothness)")
186 integral
= getQuadGK(getNegExpPDF, ninf,
0._RK,
GK15, abserr, intAbsFunc, smoothness)
187 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
188 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
192 call disp%show(
"integral = getQuadGK(getNegExpPDF, ninf, 0._RK, GK21, abserr, intAbsFunc, smoothness)")
193 integral
= getQuadGK(getNegExpPDF, ninf,
0._RK,
GK21, abserr, intAbsFunc, smoothness)
194 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
195 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
199 call disp%show(
"integral = getQuadGK(getNegExpPDF, ninf, 0._RK, GK41, abserr, intAbsFunc, smoothness)")
200 integral
= getQuadGK(getNegExpPDF, ninf,
0._RK,
GK41, abserr, intAbsFunc, smoothness)
201 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
202 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
206 call disp%show(
"integral = getQuadGK(getNegExpPDF, ninf, 0._RK, GK51, abserr, intAbsFunc, smoothness)")
207 integral
= getQuadGK(getNegExpPDF, ninf,
0._RK,
GK51, abserr, intAbsFunc, smoothness)
208 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
209 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
213 call disp%show(
"integral = getQuadGK(getNegExpPDF, ninf, 0._RK, GK61, abserr, intAbsFunc, smoothness)")
214 integral
= getQuadGK(getNegExpPDF, ninf,
0._RK,
GK61, abserr, intAbsFunc, smoothness)
215 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
216 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
220 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
221 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the Exponential distribution for non-default node counts.")
222 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
226 integer(IK) ,
parameter :: MAX_NPG
= 30_IK
228 real(RK) :: nodeK(MAX_NPG
+1), weightK(MAX_NPG
+1), weightG((MAX_NPG
+1)
/2)
229 do npg
= 1_IK, MAX_NPG
231 call disp%show(
"npg ! The number of points in the Gauss-Legendre quadrature rule.")
233 call disp%show(
"call setNodeWeightGK(nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2)) ! Compute the Gauss-Kronrod nodes and weights")
234 call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
235 call disp%show(
"integral = getQuadGK(getNegExpPDF, ninf, 0._RK, nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2), abserr, intAbsFunc, smoothness) ! Compute the (2*npg + 1)-points Gauss-Kronrod quadrature.")
236 integral
= getQuadGK(getNegExpPDF, ninf,
0._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
237 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
238 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
244 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
245 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
246 call disp%show(
"! Gauss-Kronrod quadrature over a full infinite interval (-infinity, +infinity).")
247 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
248 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
252 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
253 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the Normal distribution on the infinite range `(-infinity,+infinity)`.")
254 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
260 call disp%show(
"integral = getQuadGK(getNormPDF, ninf, pinf, GK15, abserr, intAbsFunc, smoothness)")
261 integral
= getQuadGK(getNormPDF, ninf, pinf,
GK15, abserr, intAbsFunc, smoothness)
262 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
263 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
267 call disp%show(
"integral = getQuadGK(getNormPDF, ninf, pinf, GK21, abserr, intAbsFunc, smoothness)")
268 integral
= getQuadGK(getNormPDF, ninf, pinf,
GK21, abserr, intAbsFunc, smoothness)
269 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
270 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
274 call disp%show(
"integral = getQuadGK(getNormPDF, ninf, pinf, GK41, abserr, intAbsFunc, smoothness)")
275 integral
= getQuadGK(getNormPDF, ninf, pinf,
GK41, abserr, intAbsFunc, smoothness)
276 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
277 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
281 call disp%show(
"integral = getQuadGK(getNormPDF, ninf, pinf, GK51, abserr, intAbsFunc, smoothness)")
282 integral
= getQuadGK(getNormPDF, ninf, pinf,
GK51, abserr, intAbsFunc, smoothness)
283 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
284 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
288 call disp%show(
"integral = getQuadGK(getNormPDF, ninf, pinf, GK61, abserr, intAbsFunc, smoothness)")
289 integral
= getQuadGK(getNormPDF, ninf, pinf,
GK61, abserr, intAbsFunc, smoothness)
290 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
291 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
295 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
296 call disp%show(
"! Compute the Gauss-Kronrod quadrature of the probability density function of the Normal distribution for non-default node counts.")
297 call disp%show(
"!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
301 integer(IK) ,
parameter :: MAX_NPG
= 30_IK
303 real(RK) :: nodeK(MAX_NPG
+1), weightK(MAX_NPG
+1), weightG((MAX_NPG
+1)
/2)
304 do npg
= 1_IK, MAX_NPG
306 call disp%show(
"npg ! The number of points in the Gauss-Legendre quadrature rule.")
308 call disp%show(
"call setNodeWeightGK(nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2)) ! Compute the Gauss-Kronrod nodes and weights")
309 call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
310 call disp%show(
"integral = getQuadGK(getNormPDF, ninf, pinf, nodeK(1:npg+1), weightK(1:npg+1), weightG(1:(npg+1)/2), abserr, intAbsFunc, smoothness) ! Compute the (2*npg + 1)-points Gauss-Kronrod quadrature.")
311 integral
= getQuadGK(getNormPDF, ninf, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
312 call disp%show(
"[truth, integral, abserr, intAbsFunc, smoothness, abs((integral - truth) / truth)]")
313 call disp%show( [truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)] )
320 function getBetaPDF(x)
result(pdf)
322 real(RK) ,
intent(in) :: x
327 function getLogNormPDF(x)
result(pdf)
329 real(RK) ,
intent(in) :: x
334 function getNegExpPDF(x)
result(pdf)
336 real(RK) ,
intent(in) :: x
341 function getNormPDF(x)
result(pdf)
343 real(RK) ,
intent(in) :: x
Generate and return the natural logarithm of the Probability Density Function (PDF) of the Beta distr...
Generate and return the natural logarithm of the Probability Density Function (PDF) of the Exponentia...
Generate the natural logarithm of probability density function (PDF) of the univariate Lognormal dist...
Generate the natural logarithm of probability density function (PDF) of the univariate Normal distrib...
This is a generic method of the derived type display_type with pass attribute.
This is a generic method of the derived type display_type with pass attribute.
Return the Kronrod nodes and weights of the extension to the -point Gauss-Legendre quadrature,...
This module contains classes and procedures for computing various statistical quantities related to t...
This module contains classes and procedures for computing various statistical quantities related to t...
This module contains classes and procedures for computing various statistical quantities related to t...
This module contains classes and procedures for computing various statistical quantities related to t...
This module contains classes and procedures for input/output (IO) or generic display operations on st...
type(display_type) disp
This is a scalar module variable an object of type display_type for general display.
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
integer, parameter RKH
The scalar integer constant of intrinsic default kind, representing the highest-precision real kind t...
type(GK31_type), parameter GK31
The scalar constant object of type GK31_type that indicates the use of 15-point Gauss-Legendre quadra...
type(GK51_type), parameter GK51
The scalar constant object of type GK51_type that indicates the use of 25-point Gauss-Legendre quadra...
type(GK61_type), parameter GK61
The scalar constant object of type GK61_type that indicates the use of 30-point Gauss-Legendre quadra...
type(GK21_type), parameter GK21
The scalar constant object of type GK21_type that indicates the use of 10-point Gauss-Legendre quadra...
type(GK15_type), parameter GK15
The scalar constant object of type GK15_type that indicates the use of 7-point Gauss-Legendre quadrat...
type(GK41_type), parameter GK41
The scalar constant object of type GK41_type that indicates the use of 20-point Gauss-Legendre quadra...
Generate and return an object of type display_type.
14integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK15, abserr, intAbsFunc, smoothness)
15[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
16+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.332350865347540181865392442941994453,
+0.00000000000000000000000000000000000
19integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK21, abserr, intAbsFunc, smoothness)
20[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
21+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999904,
+0.962964972193617926527988971292463541E-32,
+0.999999999999999999999999999999999904,
+0.348820029290895558486501301340103054,
+0.962964972193617926527988971292463659E-34
24integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK41, abserr, intAbsFunc, smoothness)
25[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
26+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999904,
+0.962964972193617926527988971292463541E-32,
+0.999999999999999999999999999999999904,
+0.365617398082792305848065507834403699,
+0.962964972193617926527988971292463659E-34
29integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK51, abserr, intAbsFunc, smoothness)
30[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
31+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.369298545656546792050550199588929904,
+0.192592994438723585305597794258492732E-33
34integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK,
GK61, abserr, intAbsFunc, smoothness)
35[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
36+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999904,
+0.962964972193617926527988971292463541E-32,
+0.999999999999999999999999999999999904,
+0.372002569341007109923787616661336924,
+0.962964972193617926527988971292463659E-34
46call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
47integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
48[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
49+1.00000000000000000000000000000000000,
+0.480421111969383347900839915541048870,
+0.270837007627134129622102202568011808,
+0.480421111969383347900839915541048870,
+0.270837007627134129622102202568011808,
+0.519578888030616652099160084458951130
54call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
55integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
56[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
57+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000019,
+0.962964972193617926527988971292463897E-32,
+1.00000000000000000000000000000000019,
+0.205050505050505050505050505050505040,
+0.192592994438723585305597794258492732E-33
62call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
63integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
64[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
65+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.313218923737658024129334619196987163,
+0.192592994438723585305597794258492732E-33
70call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
71integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
72[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
73+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.315930942664627962287706737178712867,
+0.192592994438723585305597794258492732E-33
78call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
79integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
80[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
81+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999904,
+0.962964972193617926527988971292463541E-32,
+0.999999999999999999999999999999999904,
+0.321609174541580455838518696237276792,
+0.962964972193617926527988971292463659E-34
86call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
87integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
88[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
89+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999711,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999711,
+0.337728935330107303671417159619312911,
+0.288889491658085377958396691387739098E-33
94call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
95integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
96[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
97+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999422,
+0.962964972193617926527988971292463066E-32,
+0.999999999999999999999999999999999422,
+0.332350865347540181865392442941993586,
+0.577778983316170755916793382775478196E-33
102call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
103integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
104[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
105+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.345422184218279383037014278751830416,
+0.00000000000000000000000000000000000
110call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
111integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
112[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
113+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000019,
+0.962964972193617926527988971292463897E-32,
+1.00000000000000000000000000000000019,
+0.348302550445394272753570649136973960,
+0.192592994438723585305597794258492732E-33
118call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
119integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
120[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
121+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.348820029290895558486501301340102573,
+0.192592994438723585305597794258492732E-33
126call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
127integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
128[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
129+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000019,
+0.962964972193617926527988971292463897E-32,
+1.00000000000000000000000000000000019,
+0.354999841253936686479701825785108681,
+0.192592994438723585305597794258492732E-33
134call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
135integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
136[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
137+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000039,
+0.962964972193617926527988971292464015E-32,
+1.00000000000000000000000000000000039,
+0.354157860946384654881202770232920338,
+0.385185988877447170611195588516985464E-33
142call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
143integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
144[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
145+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.358244419047881521537644154374837196,
+0.00000000000000000000000000000000000
150call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
151integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
152[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
153+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.360043536617096848677395286636972682,
+0.192592994438723585305597794258492732E-33
158call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
159integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
160[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
161+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.359770623875105141649427242169437024,
+0.192592994438723585305597794258492732E-33
166call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
167integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
168[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
169+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999904,
+0.962964972193617926527988971292463541E-32,
+0.999999999999999999999999999999999904,
+0.363157479470576703962170302649563992,
+0.962964972193617926527988971292463659E-34
174call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
175integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
176[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
177+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.363109511055304158303972009711228538,
+0.00000000000000000000000000000000000
182call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
183integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
184[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
185+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.364796933312968640518518780790230271,
+0.192592994438723585305597794258492732E-33
190call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
191integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
192[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
193+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999807,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999807,
+0.366088266354431031746529998266692271,
+0.192592994438723585305597794258492732E-33
198call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
199integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
200[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
201+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.365617398082792305848065507834402592,
+0.00000000000000000000000000000000000
206call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
207integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
208[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
209+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999711,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999711,
+0.367821045564605980960034310589386864,
+0.288889491658085377958396691387739098E-33
214call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
215integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
216[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
217+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000058,
+0.962964972193617926527988971292464253E-32,
+1.00000000000000000000000000000000058,
+0.367991165630253018476809914215071252,
+0.577778983316170755916793382775478196E-33
222call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
223integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
224[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
225+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999615,
+0.962964972193617926527988971292463303E-32,
+0.999999999999999999999999999999999615,
+0.368768410353483515935716732597477937,
+0.385185988877447170611195588516985464E-33
230call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
231integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
232[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
233+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999711,
+0.962964972193617926527988971292463422E-32,
+0.999999999999999999999999999999999711,
+0.369761279627099167963894850246886530,
+0.288889491658085377958396691387739098E-33
238call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
239integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
240[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
241+1.00000000000000000000000000000000000,
+0.999999999999999999999999999999999615,
+0.962964972193617926527988971292463303E-32,
+0.999999999999999999999999999999999615,
+0.369298545656546792050550199588930818,
+0.385185988877447170611195588516985464E-33
246call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
247integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
248[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
249+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.370827437016519009582483758754977133,
+0.00000000000000000000000000000000000
254call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
255integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
256[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
257+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000039,
+0.962964972193617926527988971292464015E-32,
+1.00000000000000000000000000000000039,
+0.371074860800886503248166477335971387,
+0.385185988877447170611195588516985464E-33
262call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
263integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
264[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
265+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000077,
+0.962964972193617926527988971292464371E-32,
+1.00000000000000000000000000000000077,
+0.371427050294648513107276864275321340,
+0.770371977754894341222391177033970927E-33
270call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
271integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
272[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
273+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000019,
+0.962964972193617926527988971292463897E-32,
+1.00000000000000000000000000000000019,
+0.372223979361284634235934277787081296,
+0.192592994438723585305597794258492732E-33
278call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
279integral
= getQuadGK(getBetaPDF,
0._RK,
+1._RK, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
280[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
281+1.00000000000000000000000000000000000,
+1.00000000000000000000000000000000000,
+0.962964972193617926527988971292463659E-32,
+1.00000000000000000000000000000000000,
+0.372002569341007109923787616661335335,
+0.00000000000000000000000000000000000
296integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK15, abserr, intAbsFunc, smoothness)
297[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
298+1.00000000000000000000000000000000000,
+0.999997299690519869241720281259818052,
+0.256665312152048430438215466789267068E-1,
+0.999997299690519869241720281259818052,
+0.405482311281071585135996295867852563,
+0.270030948013075827971874018194840906E-5
301integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK21, abserr, intAbsFunc, smoothness)
302[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
303+1.00000000000000000000000000000000000,
+1.00000009798761157060346918719858444,
+0.295193558106936309656912906523764044E-2,
+1.00000009798761157060346918719858444,
+0.426989872574134944871374539334134092,
+0.979876115706034691871985844378680066E-7
306integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK41, abserr, intAbsFunc, smoothness)
307[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
308+1.00000000000000000000000000000000000,
+0.999999999795081386330293090324938485,
+0.125441756876698348170916154866295533E-5,
+0.999999999795081386330293090324938485,
+0.446857633223355518536040613616829822,
+0.204918613669706909675061515079233957E-9
311integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK51, abserr, intAbsFunc, smoothness)
312[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
313+1.00000000000000000000000000000000000,
+0.999999999955606206754649785466436600,
+0.391224786873945559603990633870625383E-7,
+0.999999999955606206754649785466436600,
+0.451151051357497766162941844671249309,
+0.443937932453502145335634001947330452E-10
316integral
= getQuadGK(getLogNormPDF,
0._RK, pinf,
GK61, abserr, intAbsFunc, smoothness)
317[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
318+1.00000000000000000000000000000000000,
+0.999999999995853818011903866479753249,
+0.225157476189573037457067065221885697E-10,
+0.999999999995853818011903866479753249,
+0.454073139160562458663076636221205096,
+0.414618198809613352024675133634889360E-11
328call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
329integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
330[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
331+1.00000000000000000000000000000000000,
+0.440654390519982570923254671966087876,
+0.263157810538753065658119728890170155,
+0.440654390519982570923254671966087876,
+0.263157810538753065658119728890170155,
+0.559345609480017429076745328033912172
336call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
337integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
338[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
339+1.00000000000000000000000000000000000,
+1.00115159535561551677250223806146437,
+0.248267677849831406984651517189212306,
+1.00115159535561551677250223806146437,
+0.248267677849831406984651517189212306,
+0.115159535561551677250223806146437201E-2
344call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
345integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
346[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
347+1.00000000000000000000000000000000000,
+1.00040478970647333319876225416181032,
+0.386544757028673834265268612489689942,
+1.00040478970647333319876225416181032,
+0.386544757028673834265268612489689942,
+0.404789706473333198762254161810319913E-3
352call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
353integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
354[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
355+1.00000000000000000000000000000000000,
+1.00002610414724307748322615021718026,
+0.386231062970553098636444648476170314,
+1.00002610414724307748322615021718026,
+0.386231062970553098636444648476170314,
+0.261041472430774832261502171802586866E-4
360call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
361integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
362[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
363+1.00000000000000000000000000000000000,
+0.999985810059247339669805714912328236,
+0.394991742073170665588114892341666176,
+0.999985810059247339669805714912328236,
+0.394991742073170665588114892341666176,
+0.141899407526603301942850876717643897E-4
368call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
369integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
370[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
371+1.00000000000000000000000000000000000,
+0.999991153146646905609618866850569932,
+0.201055388449807341789299677668162966E-2,
+0.999991153146646905609618866850569932,
+0.413788278103359200140993657807761858,
+0.884685335309439038113314943006817385E-5
376call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
377integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
378[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
379+1.00000000000000000000000000000000000,
+0.999997299690519869241720281259817474,
+0.256665312152048430438215466789497668E-1,
+0.999997299690519869241720281259817474,
+0.405482311281071585135996295867851504,
+0.270030948013075827971874018252618804E-5
384call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
385integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
386[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
387+1.00000000000000000000000000000000000,
+0.999999381352227797311100131928905262,
+0.183053043078258033477296544446724386E-1,
+0.999999381352227797311100131928905262,
+0.423097534055426140755284335767787928,
+0.618647772202688899868071094737841243E-6
392call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
393integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
394[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
395+1.00000000000000000000000000000000000,
+0.999999990612983549879343252846014940,
+0.818358877620782547271452401299804686E-2,
+0.999999990612983549879343252846014940,
+0.425704502695006040033705707820210107,
+0.938701645012065674715398505995817499E-8
400call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
401integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
402[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
403+1.00000000000000000000000000000000000,
+1.00000009798761157060346918719858444,
+0.295193558106936309656912906523764233E-2,
+1.00000009798761157060346918719858444,
+0.426989872574134944871374539334133514,
+0.979876115706034691871985844378680066E-7
408call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
409integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
410[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
411+1.00000000000000000000000000000000000,
+1.00000007745615047036466107235347550,
+0.899333271967751714425000608569671298E-3,
+1.00000007745615047036466107235347550,
+0.434133277977773222279492925965094215,
+0.774561504703646610723534755037693165E-7
416call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
417integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
418[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
419+1.00000000000000000000000000000000000,
+1.00000004799397022376443202052945016,
+0.227785342107320067761047547616597876E-3,
+1.00000004799397022376443202052945016,
+0.432341032766134749110172349751338347,
+0.479939702237644320205294501602025633E-7
424call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
425integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
426[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
427+1.00000000000000000000000000000000000,
+1.00000002468784697448240228843729433,
+0.391085523137819425490135854698818053E-4,
+1.00000002468784697448240228843729433,
+0.438129154649774798484788272162522590,
+0.246878469744824022884372943262141470E-7
432call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
433integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
434[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
435+1.00000000000000000000000000000000000,
+1.00000001214523492936835710483860060,
+0.869361016703036103633369759211822842E-6,
+1.00000001214523492936835710483860060,
+0.439848436180187079104872956531366532,
+0.121452349293683571048386005983282358E-7
440call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
441integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
442[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
443+1.00000000000000000000000000000000000,
+1.00000000524709950801412578397433880,
+0.453855310215365294604835174030162360E-5,
+1.00000000524709950801412578397433880,
+0.439938137444660635481863189048735278,
+0.524709950801412578397433879702286054E-8
448call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
449integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
450[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
451+1.00000000000000000000000000000000000,
+1.00000000207728443433581482672936140,
+0.634663524822756477103426987347064793E-5,
+1.00000000207728443433581482672936140,
+0.443801817673865015557406858740782638,
+0.207728443433581482672936140386060941E-8
456call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
457integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
458[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
459+1.00000000000000000000000000000000000,
+1.00000000060138193848116631223235291,
+0.527551248353347731943956964631672420E-5,
+1.00000000060138193848116631223235291,
+0.443283372221765898366160921339535976,
+0.601381938481166312232352911385048352E-9
464call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
465integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
466[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
467+1.00000000000000000000000000000000000,
+1.00000000002337684456012439615534067,
+0.358328444953570690596202537321935925E-5,
+1.00000000002337684456012439615534067,
+0.445857503888062707775638352030904815,
+0.233768445601243961553406690044477554E-10
472call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
473integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
474[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
475+1.00000000000000000000000000000000000,
+0.999999999827357937381159052944207481,
+0.219175345657139401480060276808435034E-5,
+0.999999999827357937381159052944207481,
+0.447116124776096284469552631143427524,
+0.172642062618840947055792519112665077E-9
480call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
481integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
482[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
483+1.00000000000000000000000000000000000,
+0.999999999795081386330293090324938581,
+0.125441756876698348170916154825542999E-5,
+0.999999999795081386330293090324938581,
+0.446857633223355518536040613616828666,
+0.204918613669706909675061418782736738E-9
488call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
489integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
490[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
491+1.00000000000000000000000000000000000,
+0.999999999823694334447531529435443256,
+0.680808135708412824895859552233285701E-6,
+0.999999999823694334447531529435443256,
+0.449341868923503714056919684482635832,
+0.176305665552468470564556744368424523E-9
496call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
497integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
498[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
499+1.00000000000000000000000000000000000,
+0.999999999863908587433285676154034471,
+0.355423836548274635452003188878673935E-6,
+0.999999999863908587433285676154034471,
+0.449228245653034840442224144352105582,
+0.136091412566714323845965528887489281E-9
504call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
505integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
506[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
507+1.00000000000000000000000000000000000,
+0.999999999903139510554949594591368601,
+0.178094484871936054857683960232484674E-6,
+0.999999999903139510554949594591368601,
+0.450553065813618873446119310989872083,
+0.968604894450504054086313994102149628E-10
512call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
513integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
514[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
515+1.00000000000000000000000000000000000,
+0.999999999932930631263633182006277053,
+0.855734277235847496242840188933614528E-7,
+0.999999999932930631263633182006277053,
+0.451528553045033627003930017346024233,
+0.670693687363668179937229473940755511E-10
520call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
521integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
522[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
523+1.00000000000000000000000000000000000,
+0.999999999955606206754649785466436407,
+0.391224786873945559603990633870624924E-7,
+0.999999999955606206754649785466436407,
+0.451151051357497766162941844671250223,
+0.443937932453502145335635927877274839E-10
528call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
529integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
530[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
531+1.00000000000000000000000000000000000,
+0.999999999970905117727407763552248053,
+0.166381656789620823670390268592916473E-7,
+0.999999999970905117727407763552248053,
+0.452917709799272825368192692193337627,
+0.290948822725922364477519471835892967E-10
536call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
537integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
538[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
539+1.00000000000000000000000000000000000,
+0.999999999981605731220288947315054768,
+0.635900931335095252218769876840873286E-8,
+0.999999999981605731220288947315054768,
+0.452975362039077355596520008820995626,
+0.183942687797110526849452318238009307E-10
544call setNodeWeightGK(nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2))
545integral
= getQuadGK(getLogNormPDF,
0._RK, pinf, nodeK(
1:npg
+1), weightK(
1:npg
+1), weightG(
1:(npg
+1)
/2), abserr, intAbsFunc, smoothness)
546[truth, integral, abserr, intAbsFunc, smoothness, abs((integral
- truth)
/ truth)]
547+1.0000000000000000000000000