ParaMonte Fortran 2.0.0
Parallel Monte Carlo and Machine Learning Library
See the latest version documentation.
pm_quadPack::getQuadErr Interface Reference

Compute the 1D integral of the input scalar (potentially singular) integrand getFunc on a finite or semi/fully-infinite interval (a, b) and estimate its absolute error via the requested adaptive global Gauss-Kronrod (GK) extension rules. More...

Detailed Description

Compute the 1D integral of the input scalar (potentially singular) integrand getFunc on a finite or semi/fully-infinite interval (a, b) and estimate its absolute error via the requested adaptive global Gauss-Kronrod (GK) extension rules.

The resulting integral hopefully satisfies the accuracy condition abs(truth - result) <= max(abstol, reltol * abs(i)),
where truth is the true value of the integral and abstol, reltol are the user-specified absolute and relative tolerances, respectively.
This interface combines and significantly extends the functionalities of the QAG, QAGI, QAGP, QAGS, QAWC, QAWO, QAWS subroutines of the venerable QUADPACK library.

Specifically,

  1. When the input argument help is missing, this interface performs adaptive global Gauss-Kronrod (GK) with the user-specified predefined (7-15 (GK15), 10-21 (GK21), 15-31 (GK31), 20-41 (GK41), 25-51 (GK51), 30-61 (GK61)) Gauss-Kronrod extension rules,
    or with user-specified arbitrarily-defined Gauss-Kronrod extension rules via the triple (nodeK, weightK, weightG) input arguments.
    This interface replicates and extends the QAG/QAGE functionalities of the QuadPack library to all Gauss-Kronrod extension rules mentioned above and all real kinds supported by the processor.
  2. When the input argument help is present and set to weps, this interface accelerates the convergence of adaptive global Gauss-Kronrod (GK) with predefined or arbitrary Gauss-Kronrod rules are mentioned above, via the Epsilon extrapolation algorithm of Wynn (1961)).
    This extrapolation is particularly helpful with,
    1. integration of integrands with singularities at or within the integration limits, or
    2. integration of integrands with semi or doubly infinite integration limits,
    possibly leading to orders of magnitude speedup in computing the integral within the requested tolerance.
    This interface replicates and extends the QAGS/QAGSE functionalities of the QuadPack library to all Gauss-Kronrod extension rules and all real kinds supported by the processor.
  3. When the input argument help is present and set to a vector of points of difficulties within the integration domain, this interface accelerates the convergence of adaptive global Gauss-Kronrod (GK) with predefined or arbitrary Gauss-Kronrod rules are mentioned above via the Epsilon algorithm of Wynn (1961)).
    Simultaneously, the interface carefully takes into account the specified points of integration difficulty (such as singularities or discontinuities) specified in help.
    This interface replicates and extends the QAGP/QAGPE functionalities of the QuadPack library to all Gauss-Kronrod extension rules and all real kinds supported by the processor.
  4. When the integration limits are set to,
    1. (lb = ninf, ub), implying the semi-infinite range \((-\infty, \ms{ub})\), or
    2. (lb, ub = pinf), implying the semi-infinite range \((\ms{lb}, +\infty)\), or
    3. (lb = ninf, ub = pinf), implying the fully-infinite range \((-\infty, +\infty)\),
    this interface first applies the following corresponding change of variables,
    1. \(x = \ms{ub} - \frac{1 - t}{t}\),
    2. \(x = \ms{lb} + \frac{1 - t}{t}\),
    3. \(x = \frac{1 - t}{t}\),
    to the integrand to transform the semi/fully-infinite integration range to the finite range \((0, 1)\).
    Then it calls the user-specified interface to perform the integration.
    The functionality of this interface significantly extends the functionalities of the QAGI/QAGIE routines of the QuadPack library.
    Specifically, this interface
    1. computes integrals with arbitrary machine precision by accepting all real kinds supported by the processor.
    2. allows the use of all predefined or arbitrary Gauss-Kronrod rules for semi or fully infinite integrations.
    3. allows explicit specification of singularities or discontinuities via the input help argument for semi or fully infinite integrations.
Parameters
getFunc: The input function to be integrated (i.e., the integrand).
  1. On entry, it must take an input scalar of the same type and kind as integral.
  2. On exit, it must generate an input scalar of the same type and kind as integral, representing the corresponding function value.
The following illustrates the general interface of getFunc:
function getFunc(x) result(func)
real(RKG) , intent(in) :: x
real(RKG) :: func
end function
where RKG must match the user-specified kind type parameter for the integral output argument below.
[in]lb: The input scalar argument that can be either,
  1. a value of type real of the same kind as integral, representing the lower limit of integration, or
  2. the constant ninf, representing negative infinity ( \(-\infty\)) as the lower limit of integration.
[in]ub: The input scalar argument that can be either,
  1. a value of type real of the same kind as integral, representing the upper limit of integration, or
  2. the constant pinf, representing positive infinity ( \(+\infty\)) as the upper limit of integration.
[in]abstol: The input scalar argument of the same type and kind as integral, representing the absolute tolerance of integration.
If the estimated integration error reaches a value below this threshold, the integration is assumed to have converged.
This argument can be set to any non-negative value, including abstol = 0..
[in]reltol: The input scalar argument of the same type and kind as integral, representing the relative tolerance of integration.
If the relative accuracy of integration reaches a value below this threshold, the integration is assumed to have converged.
This argument can be set to any positive value significantly larger (e.g., \(\times10000\)) than epsilon(real(0., kind(reltol)).
A good rule of thumb is to set reltol = epsilon(real(0, kind(integral)))**(2./3.).
The integration result is generally orders of magnitude more precise than the specified reltol.
[in]qrule: The input scalar constant argument that can be either,
  1. GK15 of type GK15_type, or
  2. GK21 of type GK21_type, or
  3. GK31 of type GK31_type, or
  4. GK41 of type GK41_type, or
  5. GK51 of type GK51_type, or
  6. GK61 of type GK61_type.
The specified objects are empty and merely serve to differentiate the multitude of orders of Gauss-Kronrod quadrature rules.
For example, specifying GK15 dictates the use of 15-points Gauss-Kronrod quadrature rules for computing the integral and estimating its error.
(optional. It must be present if and only if nodeK, weightK and weightG optional input arguments are missing.)
[in]nodeK: The input contiguous vector argument of the same type and kind as integral, of size \(n + 1\), where \(n\) is the number of points in the Gauss rule to be used for the integration.
It contains the nodes of the \(n\)-points Gauss-Legendre quadrature rule and its \(n+1\)-points Kronrod extension rule.
The procedures under the generic interface setNodeWeightGK return this vector.
(optional. It must be present if and only if weightK and weightG optional input arguments are present and qrule is missing.)
[in]weightK: The input contiguous vector argument of the same type and kind as integral, of size \(n + 1\), where \(n\) is the number of points in the Gauss rule to be used for the integration.
It contains the Kronrod optimal extension weights for the \(2n+1\)-points Gauss-Legendre-Kronrod quadrature method.
The procedures under the generic interface setNodeWeightGK return this vector.
(optional. It must be present if and only if nodeK and weightG optional input arguments are present and qrule is missing.)
[in]weightG: The input contiguous vector argument of the same type and kind as integral, of size \((n + 1)/2\), where \(n\) is the number of points in the Gauss rule to be used for the integration.
It contains the weights for the \(n\)-points Gauss-Legendre quadrature method.
The procedures under the generic interface setNodeWeightGK return this vector.
(optional. It must be present if and only if nodeK and weightK optional input arguments are present and qrule is missing.)
[in]help: The input scalar constant argument that can be any of the following:
  1. The scalar constant weps of an object of type weps_type, implying the use of the Epsilon extrapolation algorithm of Wynn (1961)) for computing the integral and estimating its error.
    The specified objects are empty and merely serve to differentiate the multitude of different extrapolation methods to accelerate the integration convergence.
    Specify this argument as weps if you suspect the integrand contains integrable singularities or the integration range is semi/fully-infinite.
    In such cases, the extrapolation method can lead to orders of magnitude faster convergence of integration compared with no acceleration.
    When the input argument help is set to wesp, the integration routine corresponds to the QAGI and QAGS routines of QuadPack software.
    However, unlike QAGI and QAGS which use Gauss-Kronrod 7-15 and 10-21 quadrature rules respectively, this generic interface allows the extrapolation and acceleration of any Gauss-Kronrod quadrature rule with the Epsilon method of Wynn (1961).
    See examples below for an illustration of the speedup and appropriate use cases.
  2. A vector of non-zero length of the same type and kind as the input integral, containing the points of integration difficulty within the specified integration range (lb, ub).
    These points can be (integrable) singularities or discontinuities in the integrand that cannot not be modeled well by polynomials.
    Specifying the difficulty points, when they are known, can lead to significant computational speedups and convergence of the integral.
    On input, the specified help points must be in ascending order.
    If manual sorting is impossible, help can be sorted automatically via setSorted before calling this procedure.
    Additionally, all elements of help must be unique.
    If uniqueness is unknown at runtime, the unique elements of help can be automatically obtained via getUnique before calling this procedure.
    **When both the lower and upper limits of integration are infinities ( \((\ms{lb}, \ms{ub}) = (-\infty, +\infty)\)), the specified difficulty points in help cannot contain -1**.
    In such cases, use a simple change of variable to shift the singularity to values other than -1.
  3. A scalar constant of type wcauchy_type implying that the Cauchy Principal Value of the input function must be computed.
    In such a case, the Cauchy singularity must be stored in the cs component of the input object of wcauchy_type before calling this generic interface.
    If the integrand has more than one Cauchy pole, split the integration range such that each separate range contains only one Cauchy singularity.
    Then, pass each integrand separately to this generic interface and sum the results of the two integrations.
(optional. If missing, the procedure attempts to compute the integral without convergence-accelerating extrapolations or explicit assumptions about the singularities or discontinuities.)
[out]integral: The output scalar of type real of kind any supported by the processor (e.g., RK, RK32, RK64, or RK128), containing the integral of the specified integrand getFunc() over the specified range (lb, ub).
[out]abserr: The output scalar argument of the same type and kind as integral, representing the estimated absolute error in the resulting integral,
which should equal or exceed abs(truth - integral) where truth is the true value of the integral.
[out]sinfo: The output contiguous matrix argument of the same type and kind as integral, of size (1:4, 1:nintmax) where nintmax is the maximum number of subintervals the procedure is allowed to create to refine the computed integral.
  1. The first row, sinfo(1,1:nint), contains the lower bound of each of nint <= nintmax final surviving subintervals formed in the integration process.
  2. The second row, sinfo(2,1:nint), contains the upper bound of each of nint <= nintmax final surviving subintervals formed in the integration process.
  3. The third row, sinfo(3,1:nint), contains the estimated integral of each of nint <= nintmax final surviving subintervals formed in the integration process.
  4. The fourth row, sinfo(4,1:nint), contains the estimated integral error of each of nint <= nintmax final surviving subintervals formed in the integration process.
[out]sindex: The output contiguous vector argument of type integer of default kind IK of size (1:nintmax), the first k elements of which contain pointers to the error estimates over the subintervals,
such that sinfo(3, sindex(1)), ..., sinfo(sindex(k)) form a decreasing sequence with k = nint if nint <= (nintmax / 2 + 2), and k = nintmax - nint + 1 otherwise.
[out]neval: The output scalar argument of type integer of default kind IK, containing the number of function calls made during the integration.
[out]nint: The output scalar argument of type integer of default kind IK, containing the number of final surviving subintervals formed during the integration.
Returns
err : The output scalar of type integer of default kind IK, that is set to zero if the integration converges without any errors.
Otherwise, a non-zero value of err indicates the occurrence of an error of varying severities,
  1. If err == 1, then the maximum number of subdivisions allowed has reached.
    One can allow more subdivisions by increasing the value of limit (and taking the according dimension adjustments into account).
    However, if this yields no improvement, it is advised to analyze the integrand in order to determine the integration difficulties.
    If the position of a local difficulty can be determined (i.e., a singularity or discontinuity within the interval), one will probably gain from splitting up the interval at this point and calling the integrator on the subranges.
    If possible, an appropriate special-purpose integrator should be used which is designed for handling the type of difficulty involved.
  2. If err == 2, then the occurrence of roundoff error is detected, which prevents the requested tolerance from being achieved.
  3. If err == 3, then an extremely bad integrand behavior occurs at some points of the integration interval.
  4. If err == 4, then the algorithm has not converged on return due to the detection of roundoff errors in the extrapolation method.
    The returned result is the best that could be obtained and is not necessarily wrong.
    In such cases, check whether the output abserr is satisfactory for the specific task, even though it may be larger than the requested tolerances.
    Increasing the requested absolute and relative tolerances may help convergence.
  5. If err == 5, then the algorithm has not converged.
    The integral is likely divergent, or slowly convergent.
    Note that divergence can be the underlying cause for any of the error numbers listed here.


Possible calling interfaces ⛓

use pm_quadPack, only: getQuadErr
err = getQuadErr(getFunc, lb, ub, abstol, reltol, qrule, integral, abserr, sinfo, sindex, neval, nint) ! extends QAG/QAGI routines of QuadPack.
err = getQuadErr(getFunc, lb, ub, abstol, reltol, qrule, help, integral, abserr, sinfo, sindex, neval, nint) ! extends QAGS/QAGI/QAWC routines of QuadPack.
err = getQuadErr(getFunc, lb, ub, abstol, reltol, qrule, help(:), integral, abserr, sinfo, sindex, neval, nint) ! extends QAGS/QAGI/QAGP routines of QuadPack.
err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK(:), weightK(:), weightG(:), integral, abserr, sinfo, sindex, neval, nint) ! extends QAG/QAGI/QAWC routines of QuadPack.
err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK(:), weightK(:), weightG(:), help, integral, abserr, sinfo, sindex, neval, nint) ! extends QAGS/QAGI routines of QuadPack.
err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK(:), weightK(:), weightG(:), help(:), integral, abserr, sinfo, sindex, neval, nint) ! extends QAGS/QAGI/QAGP routines of QuadPack.
!
pm_quadPack::getQuadErr
Compute the 1D integral of the input scalar (potentially singular) integrand getFunc on a finite or s...
Definition: pm_quadPack.F90:5643
pm_quadPack
This module contains classes and procedures for non-adaptive and adaptive global numerical quadrature...
Definition: pm_quadPack.F90:141
Warning
The condition lb < ub must hold for the corresponding procedure argument.
The condition abstol > 0. must hold for the corresponding procedure arguments.
The condition reltol > 0. must hold for the corresponding procedure arguments.
The condition size(sindex) > 0_IK must hold for the corresponding procedure arguments.
The condition size(sinfo, 1) == 4_IK must hold for the corresponding procedure arguments.
The condition size(sinfo, 2) == size(sindex) must hold for the corresponding procedure arguments.
The condition size(help) > 0 must hold for the corresponding procedure arguments when help contains a set of points of difficulties within the domain of integration.
The condition all(help > lb) must hold for the corresponding procedure arguments when help contains a set of points of difficulties within the domain of integration.
The condition all(help < ub) must hold for the corresponding procedure arguments when help contains a set of points of difficulties within the domain of integration.
The condition all(help /= -1.) .and. lb == ninf .and. ub == pinf must hold for the corresponding procedure arguments when help contains a set of points of difficulties within the domain of integration.
The element values of the input help must be in ascending order when help contains a set of points of difficulties within the domain of integration.
These conditions are verified only if the library is built with the preprocessor macro CHECK_ENABLED=1.
If the target function contains points of difficulties, singularities, or discontinuities, user must ensure the abscissas of the specified Gauss-Kronrod rule do not match such points.
Particularly, computing an integrand at its singularities can lead to undefined values that can lead to unexpected segmentation fault or propagation of NaN values within the computational flow or other strange errors that can be extremely difficult to debug.
A simple check can be added within the target integrand implementations to ensure no such difficulty point matches an input value at which the function must be evaluated.
Alternatively, one should consider using the adaptive integration routines isFailedQuad or getQuadErr while setting their input help arguments to the points of difficulties of the integrand.
Remarks
The procedures under discussion are impure.
Note
semi/fully-infinite intervals
If the integration range is semi or fully infinite, the recommended quadrature rule is GK21.
Higher quadrature rules are also possible and available for semi/fully-infinite intervals although benefits could be minimal due to the introduction of the singularity in the transformed finite-range integrand.
Remarks
The procedures under discussion are impure.
See also
getQuadGK.
getQuadErr
getQuadRomb
isFailedQuad.


Example usage ⛓

1program example
2
3 use pm_kind, only: SK, IK, RKH, RKG => RKH ! All other real kinds are also supported.
4 use pm_except, only: getInfNeg, getInfPos
5 use pm_quadTest, only: int1_type
6 use pm_quadTest, only: int2_type
7 use pm_quadTest, only: int3_type
8 use pm_quadTest, only: int4_type
9 use pm_quadTest, only: int5_type
10 use pm_quadTest, only: int6_type
11 use pm_quadTest, only: int7_type
12 use pm_quadTest, only: int8_type
13 use pm_quadTest, only: int9_type
14 use pm_quadTest, only: intSinCos_type
15 use pm_quadTest, only: intNormPDF_type
16 use pm_quadTest, only: intDoncker1_type
17 use pm_quadTest, only: intDoncker2_type
18 use pm_quadTest, only: intLogNormPDF_type
19 use pm_quadTest, only: intPentaGammaInf_type
20 use pm_quadTest, only: intCauchy1_type
21 use pm_quadTest, only: intCauchy2_type
22 use pm_quadTest, only: test_getQuadErr
23 use pm_io, only: display_type
24
25 implicit none
26
27 type(display_type) :: disp
28 disp = display_type(file = "main.out.F90")
29
30 call disp%skip()
31 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
32 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
33 call disp%show("! Compare integration via the Adaptive Global Gauss-Kronrod Quadrature method with (QAG) and without (QAGS) extrapolation acceleration.")
34 call disp%show("! Note the significant efficiency improvement in the integration via QAGS when the integrand has integrable singularity at some points.")
35 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
36 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
37 call disp%skip()
38
39 call test_getQuadErr(disp, int1_type(-4._RKH, +4._RKH))
40 call test_getQuadErr(disp, int2_type(+2._RKH, +3._RKH))
41 call test_getQuadErr(disp, int3_type(ub = +3._RKH))
42 call test_getQuadErr(disp, int4_type())
43 call test_getQuadErr(disp, intSinCos_type(-4_IK, +4_IK, a = 10._RKH, b = -10._RKH))
44 call test_getQuadErr(disp, intNormPDF_type(-3._RKH, +3._RKH))
45 call test_getQuadErr(disp, intLogNormPDF_type(lb = exp(-6._RKG), ub = exp(+6._RKG)))
46
47 call disp%skip()
48 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
49 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
50 call disp%show("! Compare integration via:")
51 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method with automatic break point handling and extrapolation acceleration (QAGS),")
52 call disp%show("! with,")
53 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method with specified break point handling and extrapolation acceleration (QAGP).")
54 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
55 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
56 call disp%skip()
57
58 call test_getQuadErr(disp, int5_type(0._RKG, 3._RKG))
59 call test_getQuadErr(disp, int5_type(-2._RKG, +5._RKG))
60
61 call disp%skip()
62 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
63 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
64 call disp%show("! Compare integration via:")
65 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method without extrapolation on a semi-infinite range `(lb,+Inf)`,")
66 call disp%show("! with,")
67 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method with extrapolation on a semi-infinite range `(lb,+Inf)`.")
68 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
69 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
70 call disp%skip()
71
72 call test_getQuadErr(disp, intLogNormPDF_type())
73 call test_getQuadErr(disp, intDoncker1_type())
74 call test_getQuadErr(disp, int6_type())
75 call test_getQuadErr(disp, int7_type())
76
77 call disp%skip()
78 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
79 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
80 call disp%show("! Compare integration via:")
81 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method without extrapolation on a semi-infinite range `(-Inf, ub)`,")
82 call disp%show("! with,")
83 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method with extrapolation on a semi-infinite range `(-Inf, ub)`.")
84 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
85 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
86 call disp%skip()
87
88 call test_getQuadErr(disp, int8_type())
89 call test_getQuadErr(disp, intDoncker2_type())
90 call test_getQuadErr(disp, intDoncker2_type(ub = -1._RKG))
91
92 call disp%skip()
93 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
94 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
95 call disp%show("! Compare integration via:")
96 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method without extrapolation on a full-infinite range `(-Inf, +Inf)`,")
97 call disp%show("! with,")
98 call disp%show("! the Adaptive Global Gauss-Kronrod Quadrature method with extrapolation on a full-infinite range `(-Inf, +Inf)`.")
99 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
100 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
101 call disp%skip()
102
103 call test_getQuadErr(disp, int9_type())
104 call test_getQuadErr(disp, intNormPDF_type())
105 call test_getQuadErr(disp, intPentaGammaInf_type())
106
107 call disp%skip()
108 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
109 call disp%show("! Compute the Cauchy Principal Value over a finite interval.")
110 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
111 call disp%skip()
112
113 call test_getQuadErr(disp, intCauchy1_type())
114 call test_getQuadErr(disp, intCauchy2_type())
115
116end program example
pm_except::getInfNeg
Generate and return an IEEE-compliant negative infinity.
Definition: pm_except.F90:1719
pm_except::getInfPos
Generate and return an IEEE-compliant positive infinity.
Definition: pm_except.F90:1189
pm_io::show
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11726
pm_io::skip
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11508
pm_quadTest::test_getQuadErr
Run the adaptive global quadrature methods for the specified input integrand object.
Definition: pm_quadTest.F90:267
pm_except
This module contains procedures and generic interfaces for testing for exceptional cases at runtime.
Definition: pm_except.F90:46
pm_io
This module contains classes and procedures for input/output (IO) or generic display operations on st...
Definition: pm_io.F90:252
pm_io::disp
type(display_type) disp
This is a scalar module variable an object of type display_type for general display.
Definition: pm_io.F90:11393
pm_kind
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
Definition: pm_kind.F90:268
pm_kind::IK
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
Definition: pm_kind.F90:540
pm_kind::SK
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
Definition: pm_kind.F90:539
pm_kind::RKH
integer, parameter RKH
The scalar integer constant of intrinsic default kind, representing the highest-precision real kind t...
Definition: pm_kind.F90:858
pm_quadTest
This module contains a collection of interesting or challenging integrands for testing or examining t...
Definition: pm_quadTest.F90:54
pm_io::display_type
Generate and return an object of type display_type.
Definition: pm_io.F90:10282
pm_quadTest::int1_type
This is the derived type for generating test integrand objects of the algebraic form as described bel...
Definition: pm_quadTest.F90:331
pm_quadTest::int2_type
This is the derived type for generating test integrand objects of algebraic form as described below.
Definition: pm_quadTest.F90:412
pm_quadTest::int3_type
This is the derived type for generating test integrand objects of algebraic form as described below.
Definition: pm_quadTest.F90:489
pm_quadTest::int4_type
This is the derived type for generating test integrand objects of the following algebraic form.
Definition: pm_quadTest.F90:558
pm_quadTest::int5_type
This is the derived type for generating test integrand objects of the following algebraic form.
Definition: pm_quadTest.F90:637
pm_quadTest::int6_type
This is the derived type for generating test integrand objects of the following algebraic form.
Definition: pm_quadTest.F90:706
pm_quadTest::int7_type
This is the derived type for generating test integrand objects of the following algebraic form.
Definition: pm_quadTest.F90:779
pm_quadTest::int9_type
This is the derived type for generating test integrand objects of the following algebraic form.
Definition: pm_quadTest.F90:929
pm_quadTest::intCauchy1_type
This is the derived type for generating test integrand objects of the algebraic form as described bel...
Definition: pm_quadTest.F90:1665
pm_quadTest::intCauchy2_type
This is the derived type for generating test integrand objects of the algebraic form as described bel...
Definition: pm_quadTest.F90:1760
pm_quadTest::intDoncker1_type
This is the derived type for generating test integrand objects of algebraic form as described below.
Definition: pm_quadTest.F90:1506
pm_quadTest::intDoncker2_type
This is the derived type for generating test integrand objects of algebraic form as described below.
Definition: pm_quadTest.F90:1589
pm_quadTest::intLogNormPDF_type
This is the derived type for generating test integrand objects of the Probability Density Function of...
Definition: pm_quadTest.F90:1271
pm_quadTest::intNormPDF_type
This is the derived type for generating test integrand objects of the Probability Density Function of...
Definition: pm_quadTest.F90:1190
pm_quadTest::intPentaGammaInf_type
This is the derived type for generating test integrand objects of the sum of five Probability Density...
Definition: pm_quadTest.F90:1428
pm_quadTest::intSinCos_type
This is the derived type for generating test integrand objects of the trigonometric form as described...
Definition: pm_quadTest.F90:1111

Example Unix compile command via Intel ifort compiler ⛓
1#!/usr/bin/env sh
2rm main.exe
3ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
4./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓
1del main.exe
2set PATH=..\..\..\lib;%PATH%
3ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
4main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓
1#!/usr/bin/env sh
2rm main.exe
3gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
4./main.exe

Example output ⛓
1
2!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4! Compare integration via the Adaptive Global Gauss-Kronrod Quadrature method with (QAG) and without (QAGS) extrapolation acceleration.
5! Note the significant efficiency improvement in the integration via QAGS when the integrand has integrable singularity at some points.
6!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8
9
10!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11! int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)
12!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13
14!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
16!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17
18integrand%desc
19"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
20[abstol, reltol]
21+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
22[lb, ub]
23-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
24
25call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
26err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
27if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
28getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
290.592319847946765693983261139952398973, 0.592319847946765693983261139952399069, 0.420679694161706175066609104098715408E-29, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
30[numFuncEval, numInterval]
31+213, +2
32
33integrand%desc
34"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
35[abstol, reltol]
36+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
37[lb, ub]
38-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
39
40call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
41err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
42if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
43getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
440.592319847946765693983261139952398973, 0.592319847946765693983261139952399069, 0.420679694161706175066609104098715408E-29, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
45[numFuncEval, numInterval]
46+213, +2
47
48!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
49! Using predefined Gauss-Kronrod 30-61 nodes and weights.
50!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
51
52integrand%desc
53"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
54[abstol, reltol]
55+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
56[lb, ub]
57-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
58
59call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
60err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
61if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
62getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
630.592319847946765693983261139952398973, 0.592319847946765693983261139952395699, 0.749057713854147205376412430387292458E-25, 0.327408090545830095019516250239437644E-32 >= 1 (unbiased)? TRUE
64[numFuncEval, numInterval]
65+183, +2
66
67integrand%desc
68"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
69[abstol, reltol]
70+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
71[lb, ub]
72-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
73
74call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
75err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
76if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
77getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
780.592319847946765693983261139952398973, 0.592319847946765693983261139952395699, 0.749057713854147205376412430387292458E-25, 0.327408090545830095019516250239437644E-32 >= 1 (unbiased)? TRUE
79[numFuncEval, numInterval]
80+183, +2
81
82!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
83! Using predefined Gauss-Kronrod 25-51 nodes and weights.
84!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
85
86integrand%desc
87"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
88[abstol, reltol]
89+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
90[lb, ub]
91-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
92
93call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
94err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
95if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
96getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
970.592319847946765693983261139952398973, 0.592319847946765693983261139952399069, 0.282354400096319256248938688151661529E-30, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
98[numFuncEval, numInterval]
99+357, +4
100
101integrand%desc
102"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
103[abstol, reltol]
104+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
105[lb, ub]
106-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
107
108call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
109err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
110if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
111getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1120.592319847946765693983261139952398973, 0.592319847946765693983261139952399069, 0.282354400096319256248938688151661529E-30, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
113[numFuncEval, numInterval]
114+357, +4
115
116!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117! Using predefined Gauss-Kronrod 20-41 nodes and weights.
118!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
119
120integrand%desc
121"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
122[abstol, reltol]
123+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
124[lb, ub]
125-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
126
127call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
128err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
129if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
130getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1310.592319847946765693983261139952398973, 0.592319847946765693983261139952369891, 0.130763857408511882147171505007517289E-23, 0.290815421602472613811452669330324025E-31 >= 1 (unbiased)? TRUE
132[numFuncEval, numInterval]
133+287, +4
134
135integrand%desc
136"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
137[abstol, reltol]
138+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
139[lb, ub]
140-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
141
142call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
143err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
144if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
145getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1460.592319847946765693983261139952398973, 0.592319847946765693983261139952369891, 0.130763857408511882147171505007517289E-23, 0.290815421602472613811452669330324025E-31 >= 1 (unbiased)? TRUE
147[numFuncEval, numInterval]
148+287, +4
149
150!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
151! Using predefined Gauss-Kronrod 15-31 nodes and weights.
152!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
153
154integrand%desc
155"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
156[abstol, reltol]
157+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
158[lb, ub]
159-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
160
161call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
162err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
163if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
164getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1650.592319847946765693983261139952398973, 0.592319847946765693983261139952398973, 0.908014202174603824005803987572878882E-26, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
166[numFuncEval, numInterval]
167+341, +6
168
169integrand%desc
170"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
171[abstol, reltol]
172+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
173[lb, ub]
174-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
175
176call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
177err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
178if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
179getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1800.592319847946765693983261139952398973, 0.592319847946765693983261139952398973, 0.908014202174603824005803987572878882E-26, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
181[numFuncEval, numInterval]
182+341, +6
183
184!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
185! Using predefined Gauss-Kronrod 10-21 nodes and weights.
186!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
187
188integrand%desc
189"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
190[abstol, reltol]
191+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
192[lb, ub]
193-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
194
195call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
196err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
197if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
198getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1990.592319847946765693983261139952398973, 0.592319847946765693983261139950914562, 0.242973532478881507761272478019151270E-22, 0.148441050463646203374289499924733273E-29 >= 1 (unbiased)? TRUE
200[numFuncEval, numInterval]
201+399, +10
202
203integrand%desc
204"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
205[abstol, reltol]
206+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
207[lb, ub]
208-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
209
210call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
211err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
212if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
213getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2140.592319847946765693983261139952398973, 0.592319847946765693983261139950914466, 0.242973532478881507761272477921271703E-22, 0.148450680113368139553554779814446198E-29 >= 1 (unbiased)? TRUE
215[numFuncEval, numInterval]
216+399, +10
217
218!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
219! Using predefined Gauss-Kronrod 7-15 nodes and weights.
220!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
221
222integrand%desc
223"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
224[abstol, reltol]
225+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
226[lb, ub]
227-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
228
229call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
230err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
231if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
232getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2330.592319847946765693983261139952398973, 0.592319847946765693983261139952415054, 0.311644046752404524231338211060753717E-22, 0.160815150356334193730174158205841431E-31 >= 1 (unbiased)? TRUE
234[numFuncEval, numInterval]
235+765, +26
236
237integrand%desc
238"int1_type: an algebraic integrand of the form f(x) = x**2 / (x**2 + 1) / (x**2 + 4) for x in (lb, ub)"
239[abstol, reltol]
240+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
241[lb, ub]
242-4.00000000000000000000000000000000000, +4.00000000000000000000000000000000000
243
244call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
245err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
246if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
247getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2480.592319847946765693983261139952398973, 0.592319847946765693983261139952415054, 0.311644046752404524231537458497527643E-22, 0.160815150356334193730174158205841431E-31 >= 1 (unbiased)? TRUE
249[numFuncEval, numInterval]
250+765, +26
251
252
253!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
254! int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration
255!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
256
257!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
258! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
259!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
260
261integrand%desc
262"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
263[abstol, reltol]
264+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
265[lb, ub]
266+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
267
268call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
269err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
270if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
271
272 **** INTEGRATION FAILED: ERR = 3 ****
273
274getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2750.942809041582063365867792482806465323, 0.942809041582063353517270922122486063, 0.275996032154812596404096004412307632E-15, 0.123505215606839792599902659423179129E-16 >= 1 (unbiased)? TRUE
276[numFuncEval, numInterval]
277+14271, +101
278
279integrand%desc
280"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
281[abstol, reltol]
282+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
283[lb, ub]
284+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
285
286call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
287err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
288if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
289getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2900.942809041582063365867792482806465323, 0.942809041582063365867792482806360745, 0.780290516968488605865629463438283303E-30, 0.104577995980226906820939602282361553E-30 >= 1 (unbiased)? TRUE
291[numFuncEval, numInterval]
292+781, +6
293
294!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
295! Using predefined Gauss-Kronrod 30-61 nodes and weights.
296!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
297
298integrand%desc
299"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
300[abstol, reltol]
301+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
302[lb, ub]
303+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
304
305call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
306err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
307if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
308
309 **** INTEGRATION FAILED: ERR = 3 ****
310
311getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3120.942809041582063365867792482806465323, 0.942809041582063354181389418572630975, 0.395526291759776583849399257993266119E-15, 0.116864030642338343481331615363661636E-16 >= 1 (unbiased)? TRUE
313[numFuncEval, numInterval]
314+12261, +101
315
316integrand%desc
317"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
318[abstol, reltol]
319+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
320[lb, ub]
321+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
322
323call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
324err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
325if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
326getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3270.942809041582063365867792482806465323, 0.942809041582063365867792482806368256, 0.683127351274152557078955376234873720E-30, 0.970668691971166869940212883062803369E-31 >= 1 (unbiased)? TRUE
328[numFuncEval, numInterval]
329+671, +6
330
331!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
332! Using predefined Gauss-Kronrod 25-51 nodes and weights.
333!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
334
335integrand%desc
336"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
337[abstol, reltol]
338+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
339[lb, ub]
340+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
341
342call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
343err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
344if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
345
346 **** INTEGRATION FAILED: ERR = 3 ****
347
348getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3490.942809041582063365867792482806465323, 0.942809041582063353612391313951514454, 0.393612625583696433467216358595637327E-15, 0.122554011688549508692539077120199527E-16 >= 1 (unbiased)? TRUE
350[numFuncEval, numInterval]
351+10251, +101
352
353integrand%desc
354"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
355[abstol, reltol]
356+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
357[lb, ub]
358+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
359
360call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
361err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
362if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
363getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3640.942809041582063365867792482806465323, 0.942809041582063365867792482806399167, 0.654527291600002104661074103787487549E-30, 0.661556935897015515524728423277922534E-31 >= 1 (unbiased)? TRUE
365[numFuncEval, numInterval]
366+561, +6
367
368!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
369! Using predefined Gauss-Kronrod 20-41 nodes and weights.
370!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
371
372integrand%desc
373"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
374[abstol, reltol]
375+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
376[lb, ub]
377+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
378
379call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
380err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
381if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
382
383 **** INTEGRATION FAILED: ERR = 3 ****
384
385getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3860.942809041582063365867792482806465323, 0.942809041582063354504151452306557739, 0.393427741808206315477620382019741615E-15, 0.113636410304999075837096309795641304E-16 >= 1 (unbiased)? TRUE
387[numFuncEval, numInterval]
388+8241, +101
389
390integrand%desc
391"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
392[abstol, reltol]
393+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
394[lb, ub]
395+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
396
397call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
398err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
399if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
400getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
4010.942809041582063365867792482806465323, 0.942809041582063365867792482806474856, 0.311326575510196675646498834418853501E-30, 0.953335322471681747262709081579539023E-32 >= 1 (unbiased)? TRUE
402[numFuncEval, numInterval]
403+451, +6
404
405!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
406! Using predefined Gauss-Kronrod 15-31 nodes and weights.
407!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
408
409integrand%desc
410"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
411[abstol, reltol]
412+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
413[lb, ub]
414+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
415
416call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
417err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
418if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
419
420 **** INTEGRATION FAILED: ERR = 3 ****
421
422getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
4230.942809041582063365867792482806465323, 0.942809041582063360076317716910846285, 0.279164711945302751623913154970201256E-15, 0.579147476589561903767056045130549251E-17 >= 1 (unbiased)? TRUE
424[numFuncEval, numInterval]
425+6293, +102
426
427integrand%desc
428"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
429[abstol, reltol]
430+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
431[lb, ub]
432+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
433
434call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
435err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
436if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
437getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
4380.942809041582063365867792482806465323, 0.942809041582063365867792482806439901, 0.205400428568898703728420047576682499E-30, 0.254222752659115132603389088421210406E-31 >= 1 (unbiased)? TRUE
439[numFuncEval, numInterval]
440+341, +6
441
442!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
443! Using predefined Gauss-Kronrod 10-21 nodes and weights.
444!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
445
446integrand%desc
447"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
448[abstol, reltol]
449+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
450[lb, ub]
451+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
452
453call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
454err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
455if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
456
457 **** INTEGRATION FAILED: ERR = 3 ****
458
459getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
4600.942809041582063365867792482806465323, 0.942809041582063358489159110539769991, 0.274189625236721766830515122145815584E-15, 0.737863337226669533225571680774701636E-17 >= 1 (unbiased)? TRUE
461[numFuncEval, numInterval]
462+4263, +102
463
464integrand%desc
465"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
466[abstol, reltol]
467+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
468[lb, ub]
469+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
470
471call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
472err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
473if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
474getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
4750.942809041582063365867792482806465323, 0.942809041582063365867792482806451456, 0.747866619686254516023298199584791888E-27, 0.138666955995880981420030411866114767E-31 >= 1 (unbiased)? TRUE
476[numFuncEval, numInterval]
477+399, +10
478
479!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
480! Using predefined Gauss-Kronrod 7-15 nodes and weights.
481!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
482
483integrand%desc
484"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
485[abstol, reltol]
486+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
487[lb, ub]
488+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
489
490call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
491err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
492if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
493
494 **** INTEGRATION FAILED: ERR = 3 ****
495
496getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
4970.942809041582063365867792482806465323, 0.942809041582063352985651916754259394, 0.107881013975510488055028051825168280E-14, 0.128821405660522059292977722684510948E-16 >= 1 (unbiased)? TRUE
498[numFuncEval, numInterval]
499+3465, +116
500
501integrand%desc
502"int2_type: an algebraic integrand of the form f(x) = 1 / sqrt(a - b * x) for x in (0, a / b) with a > 0 and b > 0 with a singularity at the upper bound of integration"
503[abstol, reltol]
504+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
505[lb, ub]
506+0.00000000000000000000000000000000000, +0.666666666666666666666666666666666635
507
508call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
509err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
510if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
511getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5120.942809041582063365867792482806465323, 0.942809041582063365867792482806467056, 0.894595922874628788043750076873935104E-26, 0.173333694994851226775038014832643459E-32 >= 1 (unbiased)? TRUE
513[numFuncEval, numInterval]
514+585, +20
515
516
517!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
518! int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration
519!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
520
521!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
522! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
523!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
524
525integrand%desc
526"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
527[abstol, reltol]
528+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
529[lb, ub]
530+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
531
532call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
533err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
534if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
535getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
536-3.12249862669012531099145873075559453, -3.12249862669012531099145703288302519, 0.159554531774406733373916406327365902E-21, 0.169787256934451856030425956397998728E-23 >= 1 (unbiased)? TRUE
537[numFuncEval, numInterval]
538+22791, +161
539
540integrand%desc
541"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
542[abstol, reltol]
543+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
544[lb, ub]
545+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
546
547call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
548err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
549if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
550getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
551-3.12249862669012531099145873075559453, -3.12249862669012531099145873075586917, 0.104192809991349459650328406693844568E-29, 0.274637610069619832645782454612610636E-30 >= 1 (unbiased)? TRUE
552[numFuncEval, numInterval]
553+1065, +8
554
555!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
556! Using predefined Gauss-Kronrod 30-61 nodes and weights.
557!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
558
559integrand%desc
560"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
561[abstol, reltol]
562+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
563[lb, ub]
564+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
565
566call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
567err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
568if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
569getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
570-3.12249862669012531099145873075559453, -3.12249862669012531099145675992893943, 0.158821823031096796049113138417448082E-21, 0.197082665510145750102784224886897408E-23 >= 1 (unbiased)? TRUE
571[numFuncEval, numInterval]
572+19581, +161
573
574integrand%desc
575"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
576[abstol, reltol]
577+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
578[lb, ub]
579+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
580
581call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
582err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
583if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
584getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
585-3.12249862669012531099145873075559453, -3.12249862669012531099145873075560878, 0.295052467480124532688175820804010865E-30, 0.142518815884655453126142367751284622E-31 >= 1 (unbiased)? TRUE
586[numFuncEval, numInterval]
587+915, +8
588
589!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
590! Using predefined Gauss-Kronrod 25-51 nodes and weights.
591!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
592
593integrand%desc
594"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
595[abstol, reltol]
596+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
597[lb, ub]
598+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
599
600call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
601err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
602if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
603getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
604-3.12249862669012531099145873075559453, -3.12249862669012531099145637935769671, 0.157863935952385241531199129294364333E-21, 0.235139789781688314990001714829882296E-23 >= 1 (unbiased)? TRUE
605[numFuncEval, numInterval]
606+16371, +161
607
608integrand%desc
609"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
610[abstol, reltol]
611+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
612[lb, ub]
613+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
614
615call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
616err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
617if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
618getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
619-3.12249862669012531099145873075559453, -3.12249862669012531099145873075562303, 0.278104283969516857181283214909263505E-30, 0.285037631769310906252284735502569243E-31 >= 1 (unbiased)? TRUE
620[numFuncEval, numInterval]
621+765, +8
622
623!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
624! Using predefined Gauss-Kronrod 20-41 nodes and weights.
625!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
626
627integrand%desc
628"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
629[abstol, reltol]
630+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
631[lb, ub]
632+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
633
634call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
635err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
636if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
637getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
638-3.12249862669012531099145873075559453, -3.12249862669012531099145581781496689, 0.156352167288494027740417861647194691E-21, 0.291294062764122468285662650331711561E-23 >= 1 (unbiased)? TRUE
639[numFuncEval, numInterval]
640+13161, +161
641
642integrand%desc
643"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
644[abstol, reltol]
645+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
646[lb, ub]
647+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
648
649call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
650err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
651if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
652getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
653-3.12249862669012531099145873075559453, -3.12249862669012531099145873075552443, 0.445660189131206376397153295914152182E-30, 0.701038499756953850512375971100913544E-31 >= 1 (unbiased)? TRUE
654[numFuncEval, numInterval]
655+615, +8
656
657!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
658! Using predefined Gauss-Kronrod 15-31 nodes and weights.
659!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
660
661integrand%desc
662"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
663[abstol, reltol]
664+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
665[lb, ub]
666+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
667
668call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
669err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
670if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
671getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
672-3.12249862669012531099145873075559453, -3.12249862669012531099145489154805592, 0.153862855021951093878837768152750949E-21, 0.383920753861232441434641228203070917E-23 >= 1 (unbiased)? TRUE
673[numFuncEval, numInterval]
674+9951, +161
675
676integrand%desc
677"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
678[abstol, reltol]
679+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
680[lb, ub]
681+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
682
683call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
684err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
685if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
686getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
687-3.12249862669012531099145873075559453, -3.12249862669012531099145873075556603, 0.182963344716787406040317904545568095E-30, 0.285037631769310906252284735502569243E-31 >= 1 (unbiased)? TRUE
688[numFuncEval, numInterval]
689+465, +8
690
691!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
692! Using predefined Gauss-Kronrod 10-21 nodes and weights.
693!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
694
695integrand%desc
696"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
697[abstol, reltol]
698+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
699[lb, ub]
700+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
701
702call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
703err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
704if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
705getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
706-3.12249862669012531099145873075559453, -3.12249862669012531099145729306953740, 0.166762278786010609240106982579981836E-21, 0.143768605713088174426049560344490814E-23 >= 1 (unbiased)? TRUE
707[numFuncEval, numInterval]
708+7959, +190
709
710integrand%desc
711"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
712[abstol, reltol]
713+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
714[lb, ub]
715+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
716
717call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
718err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
719if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
720getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
721-3.12249862669012531099145873075559453, -3.12249862669012531099145873075553329, 0.638742935999207969456768107027576605E-25, 0.612445722315141001271800985742006887E-31 >= 1 (unbiased)? TRUE
722[numFuncEval, numInterval]
723+567, +14
724
725!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
726! Using predefined Gauss-Kronrod 7-15 nodes and weights.
727!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
728
729integrand%desc
730"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
731[abstol, reltol]
732+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
733[lb, ub]
734+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
735
736call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
737err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
738if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
739getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
740-3.12249862669012531099145873075559453, -3.12249862669012531099145821665001954, 0.168984966934533206681021840309021027E-21, 0.514105574994657236239111087685608621E-24 >= 1 (unbiased)? TRUE
741[numFuncEval, numInterval]
742+9345, +312
743
744integrand%desc
745"int3_type: an algebraic integrand of the form f(x) = log(x) / sqrt(x) for x in (0, ub) with a singularity at the lower limit of integration"
746[abstol, reltol]
747+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
748[lb, ub]
749+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
750
751call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
752err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
753if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
754getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
755-3.12249862669012531099145873075559453, -3.12249862669012531099145873075569198, 0.736077254850655834241784402267592237E-24, 0.974520551859941341646324838947973223E-31 >= 1 (unbiased)? TRUE
756[numFuncEval, numInterval]
757+825, +28
758
759
760!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
761! int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit
762!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
763
764!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
765! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
766!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
767
768integrand%desc
769"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
770[abstol, reltol]
771+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
772[lb, ub]
773+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
774
775call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
776err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
777if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
778getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
779-0.189275187882093321180367135892330336, -0.189275187882093321180367157318588076, 0.709016787220663753280987987987449705E-23, 0.214262577393144583924325489311691073E-25 >= 1 (unbiased)? TRUE
780[numFuncEval, numInterval]
781+7313, +52
782
783integrand%desc
784"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
785[abstol, reltol]
786+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
787[lb, ub]
788+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
789
790call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
791err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
792if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
793getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
794-0.189275187882093321180367135892330336, -0.189275187882093321180367124314328969, 0.875190015574302935869778694464445775E-23, 0.115780013668100956229775935139168619E-25 >= 1 (unbiased)? TRUE
795[numFuncEval, numInterval]
796+3053, +22
797
798!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
799! Using predefined Gauss-Kronrod 30-61 nodes and weights.
800!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
801
802integrand%desc
803"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
804[abstol, reltol]
805+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
806[lb, ub]
807+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
808
809call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
810err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
811if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
812getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
813-0.189275187882093321180367135892330336, -0.189275187882093321180367149919369956, 0.551012606285227548119424458552174544E-23, 0.140270396193317866081626615262131133E-25 >= 1 (unbiased)? TRUE
814[numFuncEval, numInterval]
815+6405, +53
816
817integrand%desc
818"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
819[abstol, reltol]
820+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
821[lb, ub]
822+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
823
824call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
825err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
826if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
827getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
828-0.189275187882093321180367135892330336, -0.189275187882093321180367089569735215, 0.151044926215718500490728968093616592E-23, 0.463225951208172227937270578607855780E-25 >= 1 (unbiased)? TRUE
829[numFuncEval, numInterval]
830+2623, +22
831
832!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
833! Using predefined Gauss-Kronrod 25-51 nodes and weights.
834!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
835
836integrand%desc
837"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
838[abstol, reltol]
839+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
840[lb, ub]
841+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
842
843call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
844err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
845if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
846getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
847-0.189275187882093321180367135892330336, -0.189275187882093321180367156609609617, 0.990374035889893040148759005915834788E-23, 0.207172792803981521991901235694034717E-25 >= 1 (unbiased)? TRUE
848[numFuncEval, numInterval]
849+5355, +53
850
851integrand%desc
852"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
853[abstol, reltol]
854+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
855[lb, ub]
856+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
857
858call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
859err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
860if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
861getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
862-0.189275187882093321180367135892330336, -0.189275187882093321180367136737390768, 0.206538524316503455750529471463185887E-23, 0.845060431740830626700484040037212854E-27 >= 1 (unbiased)? TRUE
863[numFuncEval, numInterval]
864+2295, +23
865
866!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
867! Using predefined Gauss-Kronrod 20-41 nodes and weights.
868!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
869
870integrand%desc
871"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
872[abstol, reltol]
873+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
874[lb, ub]
875+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
876
877call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
878err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
879if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
880getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
881-0.189275187882093321180367135892330336, -0.189275187882093321180367151548235028, 0.957392833849128474709628758212286240E-23, 0.156559046920400077057876054566418227E-25 >= 1 (unbiased)? TRUE
882[numFuncEval, numInterval]
883+4387, +54
884
885integrand%desc
886"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
887[abstol, reltol]
888+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
889[lb, ub]
890+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
891
892call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
893err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
894if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
895getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
896-0.189275187882093321180367135892330336, -0.189275187882093321180367053743959274, 0.171962738095825101336800150848907331E-23, 0.821483710621972264585727597482209873E-25 >= 1 (unbiased)? TRUE
897[numFuncEval, numInterval]
898+1845, +23
899
900!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
901! Using predefined Gauss-Kronrod 15-31 nodes and weights.
902!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
903
904integrand%desc
905"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
906[abstol, reltol]
907+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
908[lb, ub]
909+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
910
911call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
912err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
913if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
914getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
915-0.189275187882093321180367135892330336, -0.189275187882093321180367142295921133, 0.533449664465163971795229829978550423E-23, 0.640359079630558032326051067654102261E-26 >= 1 (unbiased)? TRUE
916[numFuncEval, numInterval]
917+3441, +56
918
919integrand%desc
920"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
921[abstol, reltol]
922+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
923[lb, ub]
924+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
925
926call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
927err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
928if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
929getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
930-0.189275187882093321180367135892330336, -0.189275187882093321180367098529961854, 0.176706130872379461913794484338831648E-23, 0.373623684826722927458878775914489365E-25 >= 1 (unbiased)? TRUE
931[numFuncEval, numInterval]
932+1457, +24
933
934!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
935! Using predefined Gauss-Kronrod 10-21 nodes and weights.
936!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
937
938integrand%desc
939"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
940[abstol, reltol]
941+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
942[lb, ub]
943+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
944
945call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
946err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
947if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
948getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
949-0.189275187882093321180367135892330336, -0.189275187882093321180367142888265418, 0.916569351771482762439666906043156170E-23, 0.699593508223454134228455499330206068E-26 >= 1 (unbiased)? TRUE
950[numFuncEval, numInterval]
951+2415, +58
952
953integrand%desc
954"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
955[abstol, reltol]
956+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
957[lb, ub]
958+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
959
960call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
961err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
962if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
963getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
964-0.189275187882093321180367135892330336, -0.189275187882093321180367392427969773, 0.530509501355781083785828386429659476E-23, 0.256535639436815431080742250597631077E-24 >= 1 (unbiased)? TRUE
965[numFuncEval, numInterval]
966+1029, +25
967
968!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
969! Using predefined Gauss-Kronrod 7-15 nodes and weights.
970!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
971
972integrand%desc
973"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
974[abstol, reltol]
975+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
976[lb, ub]
977+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
978
979call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
980err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
981if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
982getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
983-0.189275187882093321180367135892330336, -0.189275187882093321180367139165292541, 0.924243709461983056941934025837519752E-23, 0.327296220497597931940946677440670170E-26 >= 1 (unbiased)? TRUE
984[numFuncEval, numInterval]
985+2415, +81
986
987integrand%desc
988"int4_type: an algebraic integrand of the form f(x) = log(x) / (1. + log(x)**2)**2 for x in (0, 1) with a singularity at the lower limit"
989[abstol, reltol]
990+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
991[lb, ub]
992+0.00000000000000000000000000000000000, +1.00000000000000000000000000000000000
993
994call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
995err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
996if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
997getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
998-0.189275187882093321180367135892330336, -0.189275187882093321180366078398657478, 0.736851143959267756122637599455224984E-23, 0.105749367285779775551489847684084479E-23 >= 1 (unbiased)? TRUE
999[numFuncEval, numInterval]
1000+1335, +45
1001
1002
1003!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1004! intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)
1005!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1006
1007!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1008! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
1009!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1010
1011integrand%desc
1012"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1013[abstol, reltol]
1014+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1015[lb, ub]
1016-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1017
1018call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1019err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1020if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1021getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1022-6.18103992684276605416490727881801341, -6.18103992684276605416490727881803344, 0.166076809503706953025771617393152980E-30, 0.200296714216272528717821706028832441E-31 >= 1 (unbiased)? TRUE
1023[numFuncEval, numInterval]
1024+18105, +128
1025
1026integrand%desc
1027"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1028[abstol, reltol]
1029+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1030[lb, ub]
1031-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1032
1033call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1034err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1035if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1036getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1037-6.18103992684276605416490727881801341, -6.18103992684276605416490727881803344, 0.166076809503706953025771617393152980E-30, 0.200296714216272528717821706028832441E-31 >= 1 (unbiased)? TRUE
1038[numFuncEval, numInterval]
1039+18105, +128
1040
1041!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1042! Using predefined Gauss-Kronrod 30-61 nodes and weights.
1043!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1044
1045integrand%desc
1046"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1047[abstol, reltol]
1048+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1049[lb, ub]
1050-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1051
1052call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1053err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1054if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1055getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1056-6.18103992684276605416490727881801341, -6.18103992684276605416490727881804962, 0.176515061923112748728818467237145913E-30, 0.362074829544800340374523853205966336E-31 >= 1 (unbiased)? TRUE
1057[numFuncEval, numInterval]
1058+15555, +128
1059
1060integrand%desc
1061"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1062[abstol, reltol]
1063+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1064[lb, ub]
1065-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1066
1067call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1068err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1069if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1070getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1071-6.18103992684276605416490727881801341, -6.18103992684276605416490727881804962, 0.176515061923112748728818467237145913E-30, 0.362074829544800340374523853205966336E-31 >= 1 (unbiased)? TRUE
1072[numFuncEval, numInterval]
1073+15555, +128
1074
1075!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1076! Using predefined Gauss-Kronrod 25-51 nodes and weights.
1077!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1078
1079integrand%desc
1080"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1081[abstol, reltol]
1082+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1083[lb, ub]
1084-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1085
1086call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1087err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1088if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1089getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1090-6.18103992684276605416490727881801341, -6.18103992684276605416490727881803575, 0.223041390585116341659536250553811681E-23, 0.223407873548919358954493441339851569E-31 >= 1 (unbiased)? TRUE
1091[numFuncEval, numInterval]
1092+13005, +128
1093
1094integrand%desc
1095"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1096[abstol, reltol]
1097+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1098[lb, ub]
1099-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1100
1101call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1102err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1103if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1104getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1105-6.18103992684276605416490727881801341, -6.18103992684276605416490727881803575, 0.223041390585116341659536250553811681E-23, 0.223407873548919358954493441339851569E-31 >= 1 (unbiased)? TRUE
1106[numFuncEval, numInterval]
1107+13005, +128
1108
1109!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1110! Using predefined Gauss-Kronrod 20-41 nodes and weights.
1111!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1112
1113integrand%desc
1114"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1115[abstol, reltol]
1116+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1117[lb, ub]
1118-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1119
1120call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1121err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1122if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1123getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1124-6.18103992684276605416490727881801341, -6.18103992684276605416490727881803807, 0.324790916892417464705264731054702257E-21, 0.246519032881566189191165176650870697E-31 >= 1 (unbiased)? TRUE
1125[numFuncEval, numInterval]
1126+20787, +254
1127
1128integrand%desc
1129"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1130[abstol, reltol]
1131+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1132[lb, ub]
1133-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1134
1135call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1136err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1137if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1138getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1139-6.18103992684276605416490727881801341, -6.18103992684276605416490727881803807, 0.324790916892417464705264731054702257E-21, 0.246519032881566189191165176650870697E-31 >= 1 (unbiased)? TRUE
1140[numFuncEval, numInterval]
1141+20787, +254
1142
1143!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1144! Using predefined Gauss-Kronrod 15-31 nodes and weights.
1145!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1146
1147integrand%desc
1148"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1149[abstol, reltol]
1150+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1151[lb, ub]
1152-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1153
1154call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1155err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1156if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1157getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1158-6.18103992684276605416490727881801341, -6.18103992684276605416490727881800725, 0.336225917340299553880585728767591043E-21, 0.616297582203915472977912941627176742E-32 >= 1 (unbiased)? TRUE
1159[numFuncEval, numInterval]
1160+21607, +349
1161
1162integrand%desc
1163"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1164[abstol, reltol]
1165+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1166[lb, ub]
1167-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1168
1169call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1170err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1171if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1172getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1173-6.18103992684276605416490727881801341, -6.18103992684276605416490727881800725, 0.336225917340299553880585728767591043E-21, 0.616297582203915472977912941627176742E-32 >= 1 (unbiased)? TRUE
1174[numFuncEval, numInterval]
1175+21607, +349
1176
1177!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1178! Using predefined Gauss-Kronrod 10-21 nodes and weights.
1179!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1180
1181integrand%desc
1182"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1183[abstol, reltol]
1184+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1185[lb, ub]
1186-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1187
1188call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1189err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1190if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1191getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1192-6.18103992684276605416490727881801341, -6.18103992684276605416490727881796180, 0.344182590644948053094812349253319233E-21, 0.516149225095779208619002088612760521E-31 >= 1 (unbiased)? TRUE
1193[numFuncEval, numInterval]
1194+39963, +952
1195
1196integrand%desc
1197"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1198[abstol, reltol]
1199+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1200[lb, ub]
1201-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1202
1203call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1204err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1205if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1206getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1207-6.18103992684276605416490727881801341, -6.18103992684276605416490727881796180, 0.344182590644948053094812349253319233E-21, 0.516149225095779208619002088612760521E-31 >= 1 (unbiased)? TRUE
1208[numFuncEval, numInterval]
1209+39963, +952
1210
1211!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1212! Using predefined Gauss-Kronrod 7-15 nodes and weights.
1213!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1214
1215integrand%desc
1216"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1217[abstol, reltol]
1218+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1219[lb, ub]
1220-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1221
1222call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1223err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1224if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1225
1226 **** INTEGRATION FAILED: ERR = 1 ****
1227
1228getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1229-6.18103992684276605416490727881801341, -6.18103992684276605416490727881795101, 0.213754699437790813345369741909500076E-19, 0.624001301981464416390136853397516451E-31 >= 1 (unbiased)? TRUE
1230[numFuncEval, numInterval]
1231+59985, +2000
1232
1233integrand%desc
1234"intSinCos_typer(): a highly oscillatory integrand of the form f(x) = cos(a * sin(b * x)) for x in (lb, ub)"
1235[abstol, reltol]
1236+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1237[lb, ub]
1238-12.5663706143591729538505735331180112, +12.5663706143591729538505735331180112
1239
1240call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1241err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1242if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1243
1244 **** INTEGRATION FAILED: ERR = 1 ****
1245
1246getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
1247-6.18103992684276605416490727881801341, -6.18103992684276605416490727881795101, 0.213754699437790813345369741909500076E-19, 0.624001301981464416390136853397516451E-31 >= 1 (unbiased)? TRUE
1248[numFuncEval, numInterval]
1249+59985, +2000
1250
1251
1252!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1253! intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)
1254!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1255
1256!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1257! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
1258!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1259
1260integrand%desc
1261"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1262[abstol, reltol]
1263+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1264[lb, ub]
1265-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1266
1267call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1268err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1269if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1270getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
12710.997300203936739810946696370464810073, 0.997300203936739810946696370464809977, 0.960365163152632139431742870020602309E-32, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
1272[numFuncEval, numInterval]
1273+71, +1
1274
1275integrand%desc
1276"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1277[abstol, reltol]
1278+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1279[lb, ub]
1280-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1281
1282call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1283err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1284if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1285getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
12860.997300203936739810946696370464810073, 0.997300203936739810946696370464809977, 0.960365163152632139431742870020602309E-32, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
1287[numFuncEval, numInterval]
1288+71, +1
1289
1290!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1291! Using predefined Gauss-Kronrod 30-61 nodes and weights.
1292!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1293
1294integrand%desc
1295"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1296[abstol, reltol]
1297+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1298[lb, ub]
1299-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1300
1301call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1302err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1303if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1304getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
13050.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.960365163152632139431742870020602428E-32, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1306[numFuncEval, numInterval]
1307+61, +1
1308
1309integrand%desc
1310"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1311[abstol, reltol]
1312+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1313[lb, ub]
1314-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1315
1316call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1317err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1318if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1319getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
13200.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.960365163152632139431742870020602428E-32, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1321[numFuncEval, numInterval]
1322+61, +1
1323
1324!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1325! Using predefined Gauss-Kronrod 25-51 nodes and weights.
1326!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1327
1328integrand%desc
1329"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1330[abstol, reltol]
1331+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1332[lb, ub]
1333-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1334
1335call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1336err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1337if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1338getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
13390.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.960365163152632139431742870020602428E-32, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1340[numFuncEval, numInterval]
1341+51, +1
1342
1343integrand%desc
1344"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1345[abstol, reltol]
1346+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1347[lb, ub]
1348-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1349
1350call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1351err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1352if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1353getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
13540.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.960365163152632139431742870020602428E-32, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1355[numFuncEval, numInterval]
1356+51, +1
1357
1358!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1359! Using predefined Gauss-Kronrod 20-41 nodes and weights.
1360!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1361
1362integrand%desc
1363"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1364[abstol, reltol]
1365+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1366[lb, ub]
1367-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1368
1369call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1370err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1371if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1372getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
13730.997300203936739810946696370464810073, 0.997300203936739810946696370464809977, 0.889132319815101506992486479583758891E-23, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
1374[numFuncEval, numInterval]
1375+41, +1
1376
1377integrand%desc
1378"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1379[abstol, reltol]
1380+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1381[lb, ub]
1382-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1383
1384call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1385err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1386if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1387getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
13880.997300203936739810946696370464810073, 0.997300203936739810946696370464809977, 0.889132319815101506992486479583758891E-23, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
1389[numFuncEval, numInterval]
1390+41, +1
1391
1392!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1393! Using predefined Gauss-Kronrod 15-31 nodes and weights.
1394!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1395
1396integrand%desc
1397"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1398[abstol, reltol]
1399+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1400[lb, ub]
1401-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1402
1403call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1404err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1405if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1406getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
14070.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.165294620035281907669157093642640498E-27, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1408[numFuncEval, numInterval]
1409+93, +2
1410
1411integrand%desc
1412"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1413[abstol, reltol]
1414+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1415[lb, ub]
1416-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1417
1418call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1419err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1420if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1421getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
14220.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.165294620035281907669157093642640498E-27, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1423[numFuncEval, numInterval]
1424+93, +2
1425
1426!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1427! Using predefined Gauss-Kronrod 10-21 nodes and weights.
1428!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1429
1430integrand%desc
1431"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1432[abstol, reltol]
1433+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1434[lb, ub]
1435-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1436
1437call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1438err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1439if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1440getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
14410.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.863216418769238025171827058295059452E-23, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1442[numFuncEval, numInterval]
1443+147, +4
1444
1445integrand%desc
1446"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1447[abstol, reltol]
1448+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1449[lb, ub]
1450-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1451
1452call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1453err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1454if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1455getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
14560.997300203936739810946696370464810073, 0.997300203936739810946696370464810073, 0.863216418769238025171827058295059452E-23, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
1457[numFuncEval, numInterval]
1458+147, +4
1459
1460!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1461! Using predefined Gauss-Kronrod 7-15 nodes and weights.
1462!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1463
1464integrand%desc
1465"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1466[abstol, reltol]
1467+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1468[lb, ub]
1469-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1470
1471call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1472err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1473if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1474getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
14750.997300203936739810946696370464810073, 0.997300203936739810946696370464809881, 0.989078465979444977809838184337901268E-26, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
1476[numFuncEval, numInterval]
1477+465, +16
1478
1479integrand%desc
1480"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
1481[abstol, reltol]
1482+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1483[lb, ub]
1484-3.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1485
1486call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1487err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1488if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1489getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
14900.997300203936739810946696370464810073, 0.997300203936739810946696370464809881, 0.989078465979444977809838184337901268E-26, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
1491[numFuncEval, numInterval]
1492+465, +16
1493
1494
1495!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1496! intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)
1497!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1498
1499!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1500! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
1501!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1502
1503integrand%desc
1504"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1505[abstol, reltol]
1506+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1507[lb, ub]
1508+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1509
1510call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1511err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1512if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1513getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
15140.999999998026824709924603718598271714, 0.999999998026824709924603718606966421, 0.547734710492596613198428389733446047E-25, 0.869470703043339562041386522069678363E-29 >= 1 (unbiased)? TRUE
1515[numFuncEval, numInterval]
1516+1775, +13
1517
1518integrand%desc
1519"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1520[abstol, reltol]
1521+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1522[lb, ub]
1523+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1524
1525call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1526err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1527if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1528getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
15290.999999998026824709924603718598271714, 0.999999998026824709924603718606966421, 0.547734710492596613198428389733446047E-25, 0.869470703043339562041386522069678363E-29 >= 1 (unbiased)? TRUE
1530[numFuncEval, numInterval]
1531+1775, +13
1532
1533!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1534! Using predefined Gauss-Kronrod 30-61 nodes and weights.
1535!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1536
1537integrand%desc
1538"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1539[abstol, reltol]
1540+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1541[lb, ub]
1542+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1543
1544call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1545err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1546if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1547getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
15480.999999998026824709924603718598271714, 0.999999998026824709924603725273434449, 0.111572292886404739914008350309747436E-22, 0.667516273516384885871584678866435084E-26 >= 1 (unbiased)? TRUE
1549[numFuncEval, numInterval]
1550+1525, +13
1551
1552integrand%desc
1553"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1554[abstol, reltol]
1555+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1556[lb, ub]
1557+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1558
1559call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1560err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1561if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1562getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
15630.999999998026824709924603718598271714, 0.999999998026824709924603725273434449, 0.111572292886404739914008350309747436E-22, 0.667516273516384885871584678866435084E-26 >= 1 (unbiased)? TRUE
1564[numFuncEval, numInterval]
1565+1525, +13
1566
1567!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1568! Using predefined Gauss-Kronrod 25-51 nodes and weights.
1569!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1570
1571integrand%desc
1572"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1573[abstol, reltol]
1574+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1575[lb, ub]
1576+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1577
1578call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1579err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1580if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1581getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
15820.999999998026824709924603718598271714, 0.999999998026824709924603718603631866, 0.909231155365824677119168796245423356E-25, 0.536015192472133546443274501090524047E-29 >= 1 (unbiased)? TRUE
1583[numFuncEval, numInterval]
1584+1377, +14
1585
1586integrand%desc
1587"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1588[abstol, reltol]
1589+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1590[lb, ub]
1591+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1592
1593call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1594err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1595if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1596getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
15970.999999998026824709924603718598271714, 0.999999998026824709924603718603631866, 0.909231155365824677119168796245423356E-25, 0.536015192472133546443274501090524047E-29 >= 1 (unbiased)? TRUE
1598[numFuncEval, numInterval]
1599+1377, +14
1600
1601!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1602! Using predefined Gauss-Kronrod 20-41 nodes and weights.
1603!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1604
1605integrand%desc
1606"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1607[abstol, reltol]
1608+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1609[lb, ub]
1610+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1611
1612call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1613err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1614if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1615getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
16160.999999998026824709924603718598271714, 0.999999998026824709924603718598289432, 0.158903399619013173818078524001182440E-26, 0.177185554883625698481149970717813313E-31 >= 1 (unbiased)? TRUE
1617[numFuncEval, numInterval]
1618+1189, +15
1619
1620integrand%desc
1621"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1622[abstol, reltol]
1623+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1624[lb, ub]
1625+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1626
1627call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1628err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1629if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1630getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
16310.999999998026824709924603718598271714, 0.999999998026824709924603718598289432, 0.158903399619013173818078524001182440E-26, 0.177185554883625698481149970717813313E-31 >= 1 (unbiased)? TRUE
1632[numFuncEval, numInterval]
1633+1189, +15
1634
1635!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1636! Using predefined Gauss-Kronrod 15-31 nodes and weights.
1637!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1638
1639integrand%desc
1640"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1641[abstol, reltol]
1642+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1643[lb, ub]
1644+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1645
1646call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1647err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1648if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1649getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
16500.999999998026824709924603718598271714, 0.999999998026824709924603724430861091, 0.473774284927787933092831945007090199E-22, 0.583258937713082699387465474894301931E-26 >= 1 (unbiased)? TRUE
1651[numFuncEval, numInterval]
1652+899, +15
1653
1654integrand%desc
1655"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1656[abstol, reltol]
1657+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1658[lb, ub]
1659+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1660
1661call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1662err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1663if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1664getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
16650.999999998026824709924603718598271714, 0.999999998026824709924603724430861091, 0.473774284927787933092831945007090199E-22, 0.583258937713082699387465474894301931E-26 >= 1 (unbiased)? TRUE
1666[numFuncEval, numInterval]
1667+899, +15
1668
1669!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1670! Using predefined Gauss-Kronrod 10-21 nodes and weights.
1671!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1672
1673integrand%desc
1674"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1675[abstol, reltol]
1676+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1677[lb, ub]
1678+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1679
1680call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1681err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1682if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1683getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
16840.999999998026824709924603718598271714, 0.999999998026824709924603718597611697, 0.287685113478269648540938767224899488E-23, 0.660016191941505726842283640923854592E-30 >= 1 (unbiased)? TRUE
1685[numFuncEval, numInterval]
1686+1113, +27
1687
1688integrand%desc
1689"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1690[abstol, reltol]
1691+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1692[lb, ub]
1693+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1694
1695call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1696err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1697if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1698getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
16990.999999998026824709924603718598271714, 0.999999998026824709924603718597611601, 0.287685113534716101717891864391506212E-23, 0.660112488438725088634936439820983838E-30 >= 1 (unbiased)? TRUE
1700[numFuncEval, numInterval]
1701+1113, +27
1702
1703!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1704! Using predefined Gauss-Kronrod 7-15 nodes and weights.
1705!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1706
1707integrand%desc
1708"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1709[abstol, reltol]
1710+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1711[lb, ub]
1712+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1713
1714call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1715err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1716if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1717getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
17180.999999998026824709924603718598271714, 0.999999998026824709924603718598970922, 0.413911009759127321286150717768291224E-22, 0.699208866309785976451972792055457863E-30 >= 1 (unbiased)? TRUE
1719[numFuncEval, numInterval]
1720+1755, +59
1721
1722integrand%desc
1723"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
1724[abstol, reltol]
1725+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1726[lb, ub]
1727+0.247875217666635842304516743081666797E-2, +403.428793492735122608387180543388261
1728
1729call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1730err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1731if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1732getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
17330.999999998026824709924603718598271714, 0.999999998026824709924603718598970922, 0.413911009749698252358648302095278663E-22, 0.699208866309785976451972792055457863E-30 >= 1 (unbiased)? TRUE
1734[numFuncEval, numInterval]
1735+1755, +59
1736
1737
1738!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1739!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1740! Compare integration via:
1741! the Adaptive Global Gauss-Kronrod Quadrature method with automatic break point handling and extrapolation acceleration (QAGS),
1742! with,
1743! the Adaptive Global Gauss-Kronrod Quadrature method with specified break point handling and extrapolation acceleration (QAGP).
1744!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1745!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1746
1747
1748!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1749! int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]
1750!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1751
1752!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1753! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
1754!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1755
1756integrand%desc
1757"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1758[abstol, reltol]
1759+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1760[lb, ub]
1761+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1762
1763call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1764err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1765if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1766getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
176752.7407483834714449977291997202299809, 52.7407483834714449977292366379355449, 0.232948034581913058117362173197774120E-20, 0.369177055639478213906171612588075812E-22 >= 1 (unbiased)? TRUE
1768[numFuncEval, numInterval]
1769+20945, +148
1770
1771integrand%desc
1772"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1773[abstol, reltol]
1774+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1775[lb, ub]
1776+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1777
1778call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1779err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1780if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1781getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
178252.7407483834714449977291997202299809, 52.7407483834714449977292366379355449, 0.232948034581910442839641894837805126E-20, 0.369177055639478213906171612588075812E-22 >= 1 (unbiased)? TRUE
1783[numFuncEval, numInterval]
1784+20945, +148
1785
1786integrand%desc
1787"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1788[abstol, reltol]
1789+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1790[lb, ub]
1791+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1792
1793break = integrand%break
1794break
1795+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
1796call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1797err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1798if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1799getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
180052.7407483834714449977291997202299809, 52.7407483834714449977291997202300549, 0.215704153771370415542269529569511860E-30, 0.739557098644698567573495529952612090E-31 >= 1 (unbiased)? TRUE
1801[numFuncEval, numInterval]
1802+6319, +46
1803
1804!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1805! Using predefined Gauss-Kronrod 30-61 nodes and weights.
1806!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1807
1808integrand%desc
1809"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1810[abstol, reltol]
1811+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1812[lb, ub]
1813+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1814
1815call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1816err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1817if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1818getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
181952.7407483834714449977291997202299809, 52.7407483834714449977292438063205872, 0.289842740064462589430561056453025360E-20, 0.440860906062666305104910908066251817E-22 >= 1 (unbiased)? TRUE
1820[numFuncEval, numInterval]
1821+17995, +148
1822
1823integrand%desc
1824"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1825[abstol, reltol]
1826+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1827[lb, ub]
1828+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1829
1830call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1831err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1832if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1833getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
183452.7407483834714449977291997202299809, 52.7407483834714449977295184848960249, 0.693326515071374954915388451190837108E-21, 0.318764666043968291460193089320036199E-21 >= 1 (unbiased)? TRUE
1835[numFuncEval, numInterval]
1836+17629, +145
1837
1838integrand%desc
1839"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1840[abstol, reltol]
1841+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1842[lb, ub]
1843+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1844
1845break = integrand%break
1846break
1847+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
1848call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1849err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1850if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1851getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
185252.7407483834714449977291997202299809, 52.7407483834714449977291997202300118, 0.252682008703605343920944306067142464E-30, 0.308148791101957736488956470813588371E-31 >= 1 (unbiased)? TRUE
1853[numFuncEval, numInterval]
1854+5429, +46
1855
1856!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1857! Using predefined Gauss-Kronrod 25-51 nodes and weights.
1858!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1859
1860integrand%desc
1861"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1862[abstol, reltol]
1863+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1864[lb, ub]
1865+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1866
1867call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1868err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1869if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1870getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
187152.7407483834714449977291997202299809, 52.7407483834714449977292649207112954, 0.279593999482776900534868720509082035E-20, 0.652004813144543403145197148230116006E-22 >= 1 (unbiased)? TRUE
1872[numFuncEval, numInterval]
1873+15453, +152
1874
1875integrand%desc
1876"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1877[abstol, reltol]
1878+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1879[lb, ub]
1880+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1881
1882call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1883err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1884if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1885getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
188652.7407483834714449977291997202299809, 52.7407483834714449977290870687116074, 0.274753994291644172553532843780808128E-20, 0.112651518373518784579849481605177939E-21 >= 1 (unbiased)? TRUE
1887[numFuncEval, numInterval]
1888+14943, +147
1889
1890integrand%desc
1891"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1892[abstol, reltol]
1893+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1894[lb, ub]
1895+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1896
1897break = integrand%break
1898break
1899+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
1900call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1901err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1902if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1903getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
190452.7407483834714449977291997202299809, 52.7407483834714449977291997202300056, 0.258844984525644498650723435483414232E-30, 0.246519032881566189191165176650870697E-31 >= 1 (unbiased)? TRUE
1905[numFuncEval, numInterval]
1906+4539, +46
1907
1908!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1909! Using predefined Gauss-Kronrod 20-41 nodes and weights.
1910!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1911
1912integrand%desc
1913"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1914[abstol, reltol]
1915+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1916[lb, ub]
1917+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1918
1919call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1920err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1921if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1922getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
192352.7407483834714449977291997202299809, 52.7407483834714449977292367935215582, 0.251471601443466184023500098962922429E-20, 0.370732915772305750904988313404028221E-22 >= 1 (unbiased)? TRUE
1924[numFuncEval, numInterval]
1925+12997, +159
1926
1927integrand%desc
1928"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1929[abstol, reltol]
1930+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1931[lb, ub]
1932+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1933
1934call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1935err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1936if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1937getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
193852.7407483834714449977291997202299809, 52.7407483834714449977285836488177115, 0.301923442913926513603930385366954872E-21, 0.616071412269492390330983203073406400E-21 >= 1 (unbiased)? FALSE
1939[numFuncEval, numInterval]
1940+12505, +153
1941
1942integrand%desc
1943"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1944[abstol, reltol]
1945+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1946[lb, ub]
1947+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1948
1949break = integrand%break
1950break
1951+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
1952call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1953err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1954if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1955getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
195652.7407483834714449977291997202299809, 52.7407483834714449977291997202303446, 0.101072803481442137568377722426856986E-29, 0.363615573500310129056968635560034278E-30 >= 1 (unbiased)? TRUE
1957[numFuncEval, numInterval]
1958+3649, +46
1959
1960!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1961! Using predefined Gauss-Kronrod 15-31 nodes and weights.
1962!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1963
1964integrand%desc
1965"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1966[abstol, reltol]
1967+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1968[lb, ub]
1969+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1970
1971call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1972err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1973if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1974getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
197552.7407483834714449977291997202299809, 52.7407483834714449977292436198756049, 0.236976499150922248611803146063519560E-20, 0.438996456239446501688475882380567381E-22 >= 1 (unbiased)? TRUE
1976[numFuncEval, numInterval]
1977+10757, +174
1978
1979integrand%desc
1980"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1981[abstol, reltol]
1982+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1983[lb, ub]
1984+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
1985
1986call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
1987err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
1988if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
1989getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
199052.7407483834714449977291997202299809, 52.7407483834714449977291966257559157, 0.456776810745997439567234169400521718E-21, 0.309447406528561579676039582642801594E-23 >= 1 (unbiased)? TRUE
1991[numFuncEval, numInterval]
1992+10571, +171
1993
1994integrand%desc
1995"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
1996[abstol, reltol]
1997+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
1998[lb, ub]
1999+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2000
2001break = integrand%break
2002break
2003+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2004call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2005err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2006if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2007getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
200852.7407483834714449977291997202299809, 52.7407483834714449977291997202299378, 0.101565841547205269946760052780158727E-28, 0.431408307542740831084539059139023719E-31 >= 1 (unbiased)? TRUE
2009[numFuncEval, numInterval]
2010+2759, +46
2011
2012!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2013! Using predefined Gauss-Kronrod 10-21 nodes and weights.
2014!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2015
2016integrand%desc
2017"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2018[abstol, reltol]
2019+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2020[lb, ub]
2021+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2022
2023call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2024err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2025if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2026getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
202752.7407483834714449977291997202299809, 52.7407483834714449977291982119430973, 0.281626577137703108527091583183984416E-20, 0.150828688369907653358743503038319383E-23 >= 1 (unbiased)? TRUE
2028[numFuncEval, numInterval]
2029+9933, +237
2030
2031integrand%desc
2032"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2033[abstol, reltol]
2034+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2035[lb, ub]
2036+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2037
2038call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2039err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2040if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2041getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
204252.7407483834714449977291997202299809, 52.7407483834714449977293756512978794, 0.254999378299648692241095276481594183E-20, 0.175931067898488635329681605170223821E-21 >= 1 (unbiased)? TRUE
2043[numFuncEval, numInterval]
2044+9807, +234
2045
2046integrand%desc
2047"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2048[abstol, reltol]
2049+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2050[lb, ub]
2051+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2052
2053break = integrand%break
2054break
2055+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2056call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2057err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2058if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2059getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
206052.7407483834714449977291997202299809, 52.7407483834714449977291997195885076, 0.145934789324395373910560032466299001E-21, 0.641473338436945420049060685292646912E-27 >= 1 (unbiased)? TRUE
2061[numFuncEval, numInterval]
2062+2079, +51
2063
2064!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2065! Using predefined Gauss-Kronrod 7-15 nodes and weights.
2066!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2067
2068integrand%desc
2069"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2070[abstol, reltol]
2071+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2072[lb, ub]
2073+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2074
2075call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2076err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2077if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2078getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
207952.7407483834714449977291997202299809, 52.7407483834714449977292167635249410, 0.293274362483881910135101178347983001E-20, 0.170432949600210965006781892119767990E-22 >= 1 (unbiased)? TRUE
2080[numFuncEval, numInterval]
2081+11895, +397
2082
2083integrand%desc
2084"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2085[abstol, reltol]
2086+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2087[lb, ub]
2088+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2089
2090call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2091err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2092if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2093getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
209452.7407483834714449977291997202299809, 52.7407483834714449977292912037018482, 0.861440250501809415940640073786542392E-21, 0.914834718672150527668310362914449166E-22 >= 1 (unbiased)? TRUE
2095[numFuncEval, numInterval]
2096+11805, +394
2097
2098integrand%desc
2099"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (0., 3.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2100[abstol, reltol]
2101+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2102[lb, ub]
2103+0.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
2104
2105break = integrand%break
2106break
2107+1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2108call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2109err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2110if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2111getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
211252.7407483834714449977291997202299809, 52.7407483834714449977291997202766717, 0.177820485224825466168110304633011622E-21, 0.466907048277686362328066844576749100E-28 >= 1 (unbiased)? TRUE
2113[numFuncEval, numInterval]
2114+3675, +124
2115
2116
2117!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2118! int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]
2119!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2120
2121!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2122! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
2123!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2124
2125integrand%desc
2126"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2127[abstol, reltol]
2128+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2129[lb, ub]
2130-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2131
2132call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2133err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2134if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2135getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2136808.362636933094758891687400938039628, 808.362636933094758891687471893973174, 0.420428066044995247619779893403061725E-19, 0.709559335465196559320351946024423056E-22 >= 1 (unbiased)? TRUE
2137[numFuncEval, numInterval]
2138+38695, +273
2139
2140integrand%desc
2141"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2142[abstol, reltol]
2143+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2144[lb, ub]
2145-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2146
2147call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2148err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2149if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2150getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2151808.362636933094758891687400938039628, 808.362636933094758891688933312264848, 0.269985834833653133208257528689778831E-19, 0.153237422522047254007449471466291762E-20 >= 1 (unbiased)? TRUE
2152[numFuncEval, numInterval]
2153+37133, +262
2154
2155integrand%desc
2156"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2157[abstol, reltol]
2158+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2159[lb, ub]
2160-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2161
2162break = integrand%break
2163break
2164-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2165call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2166err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2167if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2168getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2169808.362636933094758891687400938039628, 808.362636933094758891687400938039430, 0.246519032881566189191165176650870697E-29, 0.197215226305252951352932141320696557E-30 >= 1 (unbiased)? TRUE
2170[numFuncEval, numInterval]
2171+9443, +69
2172
2173!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2174! Using predefined Gauss-Kronrod 30-61 nodes and weights.
2175!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2176
2177integrand%desc
2178"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2179[abstol, reltol]
2180+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2181[lb, ub]
2182-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2183
2184call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2185err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2186if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2187getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2188808.362636933094758891687400938039628, 808.362636933094758891651413809911292, 0.402768140965438604201265877918852738E-19, 0.359871281283357411621820403619443520E-19 >= 1 (unbiased)? TRUE
2189[numFuncEval, numInterval]
2190+32269, +265
2191
2192integrand%desc
2193"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2194[abstol, reltol]
2195+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2196[lb, ub]
2197-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2198
2199call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2200err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2201if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2202getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2203808.362636933094758891687400938039628, 808.362636933094758891649522978239936, 0.315581333195617989058840370349038907E-19, 0.378779597996917572594531696750093715E-19 >= 1 (unbiased)? FALSE
2204[numFuncEval, numInterval]
2205+32025, +263
2206
2207integrand%desc
2208"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2209[abstol, reltol]
2210+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2211[lb, ub]
2212-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2213
2214break = integrand%break
2215break
2216-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2217call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2218err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2219if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2220getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2221808.362636933094758891687400938039628, 808.362636933094758891687400938039135, 0.364848168664717960002924461443288631E-29, 0.493038065763132378382330353301741394E-30 >= 1 (unbiased)? TRUE
2222[numFuncEval, numInterval]
2223+8113, +69
2224
2225!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2226! Using predefined Gauss-Kronrod 25-51 nodes and weights.
2227!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2228
2229integrand%desc
2230"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2231[abstol, reltol]
2232+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2233[lb, ub]
2234-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2235
2236call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2237err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2238if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2239getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2240808.362636933094758891687400938039628, 808.362636933094758891687515486860670, 0.418903792734497197692678797433228734E-19, 0.114548821042530639855580291570679978E-21 >= 1 (unbiased)? TRUE
2241[numFuncEval, numInterval]
2242+28407, +279
2243
2244integrand%desc
2245"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2246[abstol, reltol]
2247+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2248[lb, ub]
2249-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2250
2251call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2252err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2253if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2254getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2255808.362636933094758891687400938039628, 808.362636933094758891686643352163873, 0.288824415172313077899846899168836500E-19, 0.757585875754799176519244678488478361E-21 >= 1 (unbiased)? TRUE
2256[numFuncEval, numInterval]
2257+27591, +271
2258
2259integrand%desc
2260"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2261[abstol, reltol]
2262+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2263[lb, ub]
2264-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2265
2266break = integrand%break
2267break
2268-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2269call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2270err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2271if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2272getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2273808.362636933094758891687400938039628, 808.362636933094758891687400938040022, 0.177493703674727656217638927188626902E-29, 0.394430452610505902705864282641393115E-30 >= 1 (unbiased)? TRUE
2274[numFuncEval, numInterval]
2275+6783, +69
2276
2277!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2278! Using predefined Gauss-Kronrod 20-41 nodes and weights.
2279!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2280
2281integrand%desc
2282"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2283[abstol, reltol]
2284+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2285[lb, ub]
2286-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2287
2288call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2289err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2290if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2291getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2292808.362636933094758891687400938039628, 808.362636933094758891686464461756229, 0.425591066993900818172003255308945527E-19, 0.936476283398807666973875222659582878E-21 >= 1 (unbiased)? TRUE
2293[numFuncEval, numInterval]
2294+23493, +287
2295
2296integrand%desc
2297"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2298[abstol, reltol]
2299+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2300[lb, ub]
2301-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2302
2303call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2304err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2305if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2306getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2307808.362636933094758891687400938039628, 808.362636933094758891656690794454032, 0.107724197210109923778700366568685096E-19, 0.307101435855953070267010200542346135E-19 >= 1 (unbiased)? FALSE
2308[numFuncEval, numInterval]
2309+21689, +265
2310
2311integrand%desc
2312"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2313[abstol, reltol]
2314+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2315[lb, ub]
2316-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2317
2318break = integrand%break
2319break
2320-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2321call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2322err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2323if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2324getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2325808.362636933094758891687400938039628, 808.362636933094758891687400938039923, 0.212193722743136913008187337454003461E-26, 0.295822839457879427029398211981044836E-30 >= 1 (unbiased)? TRUE
2326[numFuncEval, numInterval]
2327+5453, +69
2328
2329!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2330! Using predefined Gauss-Kronrod 15-31 nodes and weights.
2331!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2332
2333integrand%desc
2334"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2335[abstol, reltol]
2336+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2337[lb, ub]
2338-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2339
2340call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2341err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2342if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2343getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2344808.362636933094758891687400938039628, 808.362636933094758891687316466735109, 0.432311912826119020347975498797484685E-19, 0.844713045185488530720419602668712071E-22 >= 1 (unbiased)? TRUE
2345[numFuncEval, numInterval]
2346+19995, +323
2347
2348integrand%desc
2349"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2350[abstol, reltol]
2351+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2352[lb, ub]
2353-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2354
2355call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2356err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2357if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2358getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2359808.362636933094758891687400938039628, 808.362636933094758891689755023479920, 0.311407590357648733831817146933149767E-19, 0.235408544029224495211061935024713382E-20 >= 1 (unbiased)? TRUE
2360[numFuncEval, numInterval]
2361+19375, +313
2362
2363integrand%desc
2364"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2365[abstol, reltol]
2366+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2367[lb, ub]
2368-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2369
2370break = integrand%break
2371break
2372-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2373call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2374err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2375if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2376getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2377808.362636933094758891687400938039628, 808.362636933094758891687400938040811, 0.104320158469684842706990865300722076E-21, 0.118329135783151770811759284792417934E-29 >= 1 (unbiased)? TRUE
2378[numFuncEval, numInterval]
2379+4123, +69
2380
2381!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2382! Using predefined Gauss-Kronrod 10-21 nodes and weights.
2383!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2384
2385integrand%desc
2386"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2387[abstol, reltol]
2388+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2389[lb, ub]
2390-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2391
2392call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2393err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2394if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2395getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2396808.362636933094758891687400938039628, 808.362636933094758891687472727908803, 0.434911218511979220600726133842225228E-19, 0.717898691750040911309963439262167849E-22 >= 1 (unbiased)? TRUE
2397[numFuncEval, numInterval]
2398+18627, +444
2399
2400integrand%desc
2401"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2402[abstol, reltol]
2403+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2404[lb, ub]
2405-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2406
2407call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2408err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2409if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2410getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2411808.362636933094758891687400938039628, 808.362636933094758891681251377390012, 0.334323222985259195957959902664314400E-20, 0.614956064961550876359035768078158290E-20 >= 1 (unbiased)? FALSE
2412[numFuncEval, numInterval]
2413+17703, +422
2414
2415integrand%desc
2416"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2417[abstol, reltol]
2418+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2419[lb, ub]
2420-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2421
2422break = integrand%break
2423break
2424-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2425call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2426err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2427if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2428getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2429808.362636933094758891687400938039628, 808.362636933094758891687400937280645, 0.990216586020630180919255548708256071E-21, 0.758982798435765983281759345872700701E-27 >= 1 (unbiased)? TRUE
2430[numFuncEval, numInterval]
2431+3045, +75
2432
2433!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2434! Using predefined Gauss-Kronrod 7-15 nodes and weights.
2435!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2436
2437integrand%desc
2438"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2439[abstol, reltol]
2440+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2441[lb, ub]
2442-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2443
2444call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2445err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2446if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2447getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2448808.362636933094758891687400938039628, 808.362636933094758891687456378802632, 0.440491446502510165141378304194197183E-19, 0.554407630046850353251283669973129020E-22 >= 1 (unbiased)? TRUE
2449[numFuncEval, numInterval]
2450+21765, +726
2451
2452integrand%desc
2453"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2454[abstol, reltol]
2455+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2456[lb, ub]
2457-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2458
2459call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2460err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2461if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2462getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2463808.362636933094758891687400938039628, 808.362636933094758891668516912233589, 0.822355585689238246612019374627950373E-20, 0.188840258060384384249410278092701028E-19 >= 1 (unbiased)? FALSE
2464[numFuncEval, numInterval]
2465+20775, +693
2466
2467integrand%desc
2468"int5_type: an algebraic integrand of the form f(x) = x**3 log(abs((x**2 - 1) * (x**2 - 2))) for x in (-2., 5.) with 4 possible singularities: [-sqrt(2.), -1., 1., sqrt(2.)]"
2469[abstol, reltol]
2470+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2471[lb, ub]
2472-2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000
2473
2474break = integrand%break
2475break
2476-1.41421356237309504880168872420969798, -1.00000000000000000000000000000000000, +1.00000000000000000000000000000000000, +1.41421356237309504880168872420969798
2477call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2478err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2479if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2480getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
2481808.362636933094758891687400938039628, 808.362636933094758891687400937605951, 0.111546774718161097677219975523034831E-20, 0.433676282645251240025097778764211730E-27 >= 1 (unbiased)? TRUE
2482[numFuncEval, numInterval]
2483+5205, +176
2484
2485
2486!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2487!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2488! Compare integration via:
2489! the Adaptive Global Gauss-Kronrod Quadrature method without extrapolation on a semi-infinite range `(lb,+Inf)`,
2490! with,
2491! the Adaptive Global Gauss-Kronrod Quadrature method with extrapolation on a semi-infinite range `(lb,+Inf)`.
2492!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2493!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2494
2495
2496!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2497! intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)
2498!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2499
2500!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2501! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
2502!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2503
2504integrand%desc
2505"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2506[abstol, reltol]
2507+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2508[lb, ub]
2509+0.00000000000000000000000000000000000, +Inf
2510
2511call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2512err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2513if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2514getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
25151.00000000000000000000000000000000000, 1.00000000000000000000000683093738751, 0.107548465526929774899346799170100514E-22, 0.683093738750686545518761614413113403E-23 >= 1 (unbiased)? TRUE
2516[numFuncEval, numInterval]
2517+1349, +10
2518
2519integrand%desc
2520"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2521[abstol, reltol]
2522+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2523[lb, ub]
2524+0.00000000000000000000000000000000000, +Inf
2525
2526call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2527err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2528if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2529getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
25301.00000000000000000000000000000000000, 1.00000000000000000000000683093738751, 0.107548465526929774899346799170100514E-22, 0.683093738750686545518761614413113403E-23 >= 1 (unbiased)? TRUE
2531[numFuncEval, numInterval]
2532+1349, +10
2533
2534!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2535! Using predefined Gauss-Kronrod 30-61 nodes and weights.
2536!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2537
2538integrand%desc
2539"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2540[abstol, reltol]
2541+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2542[lb, ub]
2543+0.00000000000000000000000000000000000, +Inf
2544
2545call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2546err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2547if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2548getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
25491.00000000000000000000000000000000000, 0.999999999999999999999999939736407215, 0.600429978202030731308364645561707562E-24, 0.602635927846961645320151725548255656E-25 >= 1 (unbiased)? TRUE
2550[numFuncEval, numInterval]
2551+1403, +12
2552
2553integrand%desc
2554"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2555[abstol, reltol]
2556+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2557[lb, ub]
2558+0.00000000000000000000000000000000000, +Inf
2559
2560call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2561err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2562if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2563getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
25641.00000000000000000000000000000000000, 0.999999999999999999999999939736407215, 0.600429978202030731308364645561707562E-24, 0.602635927846961645320151725548255656E-25 >= 1 (unbiased)? TRUE
2565[numFuncEval, numInterval]
2566+1403, +12
2567
2568!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2569! Using predefined Gauss-Kronrod 25-51 nodes and weights.
2570!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2571
2572integrand%desc
2573"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2574[abstol, reltol]
2575+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2576[lb, ub]
2577+0.00000000000000000000000000000000000, +Inf
2578
2579call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2580err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2581if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2582getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
25831.00000000000000000000000000000000000, 1.00000000000000000000000484242643363, 0.261137973809069354723001214234638665E-22, 0.484242643362555919451450079017564117E-23 >= 1 (unbiased)? TRUE
2584[numFuncEval, numInterval]
2585+1173, +12
2586
2587integrand%desc
2588"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2589[abstol, reltol]
2590+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2591[lb, ub]
2592+0.00000000000000000000000000000000000, +Inf
2593
2594call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2595err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2596if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2597getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
25981.00000000000000000000000000000000000, 1.00000000000000000000000484242643363, 0.261137973809069354723001214234638665E-22, 0.484242643362555919451450079017564117E-23 >= 1 (unbiased)? TRUE
2599[numFuncEval, numInterval]
2600+1173, +12
2601
2602!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2603! Using predefined Gauss-Kronrod 20-41 nodes and weights.
2604!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2605
2606integrand%desc
2607"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2608[abstol, reltol]
2609+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2610[lb, ub]
2611+0.00000000000000000000000000000000000, +Inf
2612
2613call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2614err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2615if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2616getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
26171.00000000000000000000000000000000000, 1.00000000000000000000000006863277634, 0.329563195481091717165227829005320597E-23, 0.686327763433308101870535294524986280E-25 >= 1 (unbiased)? TRUE
2618[numFuncEval, numInterval]
2619+1107, +14
2620
2621integrand%desc
2622"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2623[abstol, reltol]
2624+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2625[lb, ub]
2626+0.00000000000000000000000000000000000, +Inf
2627
2628call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2629err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2630if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2631getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
26321.00000000000000000000000000000000000, 1.00000000000000000000000006863277634, 0.329563195481091717165227829005320597E-23, 0.686327763433308101870535294524986280E-25 >= 1 (unbiased)? TRUE
2633[numFuncEval, numInterval]
2634+1107, +14
2635
2636!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2637! Using predefined Gauss-Kronrod 15-31 nodes and weights.
2638!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2639
2640integrand%desc
2641"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2642[abstol, reltol]
2643+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2644[lb, ub]
2645+0.00000000000000000000000000000000000, +Inf
2646
2647call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2648err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2649if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2650getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
26511.00000000000000000000000000000000000, 0.999999999999999999999999943674824462, 0.131595391208190529455108945051666084E-22, 0.563251755375416056268739438945854252E-25 >= 1 (unbiased)? TRUE
2652[numFuncEval, numInterval]
2653+961, +16
2654
2655integrand%desc
2656"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2657[abstol, reltol]
2658+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2659[lb, ub]
2660+0.00000000000000000000000000000000000, +Inf
2661
2662call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2663err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2664if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2665getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
26661.00000000000000000000000000000000000, 0.999999999999999999999999943674824462, 0.131595391208190529455108945051666084E-22, 0.563251755375416056268739438945854252E-25 >= 1 (unbiased)? TRUE
2667[numFuncEval, numInterval]
2668+961, +16
2669
2670!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2671! Using predefined Gauss-Kronrod 10-21 nodes and weights.
2672!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2673
2674integrand%desc
2675"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2676[abstol, reltol]
2677+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2678[lb, ub]
2679+0.00000000000000000000000000000000000, +Inf
2680
2681call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2682err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2683if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2684getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
26851.00000000000000000000000000000000000, 1.00000000000000000000000005509718469, 0.185875326636098607607964145008442373E-22, 0.550971846938518212456720189377984095E-25 >= 1 (unbiased)? TRUE
2686[numFuncEval, numInterval]
2687+735, +18
2688
2689integrand%desc
2690"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2691[abstol, reltol]
2692+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2693[lb, ub]
2694+0.00000000000000000000000000000000000, +Inf
2695
2696call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2697err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2698if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2699getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
27001.00000000000000000000000000000000000, 1.00000000000000000000000005509718469, 0.185875326636098606689609183428530258E-22, 0.550971846938518212456720189377984095E-25 >= 1 (unbiased)? TRUE
2701[numFuncEval, numInterval]
2702+735, +18
2703
2704!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2705! Using predefined Gauss-Kronrod 7-15 nodes and weights.
2706!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2707
2708integrand%desc
2709"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2710[abstol, reltol]
2711+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2712[lb, ub]
2713+0.00000000000000000000000000000000000, +Inf
2714
2715call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2716err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2717if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2718getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
27191.00000000000000000000000000000000000, 0.999999999999999999999999999201192244, 0.502632205254390581980142979518399244E-22, 0.798807755604788562422006774562854604E-27 >= 1 (unbiased)? TRUE
2720[numFuncEval, numInterval]
2721+1245, +42
2722
2723integrand%desc
2724"intLogNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (x * sigma * sqrt(2 * acos(-1.))) for x in (0 <= lb, ub)"
2725[abstol, reltol]
2726+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2727[lb, ub]
2728+0.00000000000000000000000000000000000, +Inf
2729
2730call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2731err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2732if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2733getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
27341.00000000000000000000000000000000000, 0.999999999999999999999999999201192244, 0.502632205254390576996016670287735371E-22, 0.798807755604788562422006774562854604E-27 >= 1 (unbiased)? TRUE
2735[numFuncEval, numInterval]
2736+1245, +42
2737
2738
2739!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2740! intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0
2741!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2742
2743!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2744! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
2745!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2746
2747integrand%desc
2748"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2749[abstol, reltol]
2750+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2751[lb, ub]
2752+0.00000000000000000000000000000000000, +Inf
2753
2754call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2755err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2756if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2757
2758 **** INTEGRATION FAILED: ERR = 3 ****
2759
2760getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
27613.14159265358979323846264338327950280, 3.14159265358979321522591241908331849, 0.208296085374979030073347323675135307E-14, 0.232367309641961843090786165022738858E-16 >= 1 (unbiased)? TRUE
2762[numFuncEval, numInterval]
2763+28187, +199
2764
2765integrand%desc
2766"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2767[abstol, reltol]
2768+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2769[lb, ub]
2770+0.00000000000000000000000000000000000, +Inf
2771
2772call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2773err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2774if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2775getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
27763.14159265358979323846264338327950280, 3.14159265358979323846264338331126023, 0.841166273885282742541162361664315890E-23, 0.317574292249788868753812426864599005E-28 >= 1 (unbiased)? TRUE
2777[numFuncEval, numInterval]
2778+3337, +24
2779
2780!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2781! Using predefined Gauss-Kronrod 30-61 nodes and weights.
2782!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2783
2784integrand%desc
2785"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2786[abstol, reltol]
2787+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2788[lb, ub]
2789+0.00000000000000000000000000000000000, +Inf
2790
2791call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2792err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2793if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2794
2795 **** INTEGRATION FAILED: ERR = 3 ****
2796
2797getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
27983.14159265358979323846264338327950280, 3.14159265358979321521966862186854363, 0.207806142908620680924945166813662624E-14, 0.232429747614109591667650366812964584E-16 >= 1 (unbiased)? TRUE
2799[numFuncEval, numInterval]
2800+24217, +199
2801
2802integrand%desc
2803"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2804[abstol, reltol]
2805+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2806[lb, ub]
2807+0.00000000000000000000000000000000000, +Inf
2808
2809call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2810err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2811if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2812getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
28133.14159265358979323846264338327950280, 3.14159265358979323846264338326861128, 0.332287423097541913601087094762350108E-22, 0.108915190214986961962021664609062810E-28 >= 1 (unbiased)? TRUE
2814[numFuncEval, numInterval]
2815+2867, +24
2816
2817!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2818! Using predefined Gauss-Kronrod 25-51 nodes and weights.
2819!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2820
2821integrand%desc
2822"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2823[abstol, reltol]
2824+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2825[lb, ub]
2826+0.00000000000000000000000000000000000, +Inf
2827
2828call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2829err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2830if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2831
2832 **** INTEGRATION FAILED: ERR = 3 ****
2833
2834getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
28353.14159265358979323846264338327950280, 3.14159265358979321009254441360505564, 0.206563802792221812436188991440778625E-14, 0.283700989696744471552080002689140613E-16 >= 1 (unbiased)? TRUE
2836[numFuncEval, numInterval]
2837+20247, +199
2838
2839integrand%desc
2840"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2841[abstol, reltol]
2842+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2843[lb, ub]
2844+0.00000000000000000000000000000000000, +Inf
2845
2846call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2847err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2848if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2849getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
28503.14159265358979323846264338327950280, 3.14159265358979323846264338332671581, 0.165084974300155469787476838672445514E-21, 0.472130170286864545961554656757039423E-28 >= 1 (unbiased)? TRUE
2851[numFuncEval, numInterval]
2852+2397, +24
2853
2854!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2855! Using predefined Gauss-Kronrod 20-41 nodes and weights.
2856!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2857
2858integrand%desc
2859"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2860[abstol, reltol]
2861+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2862[lb, ub]
2863+0.00000000000000000000000000000000000, +Inf
2864
2865call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2866err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2867if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2868
2869 **** INTEGRATION FAILED: ERR = 3 ****
2870
2871getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
28723.14159265358979323846264338327950280, 3.14159265358979320090361483635797009, 0.204367780502843647659060653666203424E-14, 0.375590285469215327041574060919180980E-16 >= 1 (unbiased)? TRUE
2873[numFuncEval, numInterval]
2874+16277, +199
2875
2876integrand%desc
2877"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2878[abstol, reltol]
2879+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2880[lb, ub]
2881+0.00000000000000000000000000000000000, +Inf
2882
2883call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2884err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2885if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2886getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
28873.14159265358979323846264338327950280, 3.14159265358979323846264338329217118, 0.297149168477122618111980760477178032E-24, 0.126683819881903599942316117107351349E-28 >= 1 (unbiased)? TRUE
2888[numFuncEval, numInterval]
2889+2091, +26
2890
2891!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2892! Using predefined Gauss-Kronrod 15-31 nodes and weights.
2893!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2894
2895integrand%desc
2896"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2897[abstol, reltol]
2898+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2899[lb, ub]
2900+0.00000000000000000000000000000000000, +Inf
2901
2902call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2903err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2904if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2905
2906 **** INTEGRATION FAILED: ERR = 3 ****
2907
2908getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
29093.14159265358979323846264338327950280, 3.14159265358979320535631068829316991, 0.142431324293359519823096200970219034E-14, 0.331063326949863328857070567981938374E-16 >= 1 (unbiased)? TRUE
2910[numFuncEval, numInterval]
2911+12431, +201
2912
2913integrand%desc
2914"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2915[abstol, reltol]
2916+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2917[lb, ub]
2918+0.00000000000000000000000000000000000, +Inf
2919
2920call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2921err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2922if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2923getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
29243.14159265358979323846264338327950280, 3.14159265358979323846264338329720286, 0.631470999045538752417512719581846634E-23, 0.177000665608964523839256596835325160E-28 >= 1 (unbiased)? TRUE
2925[numFuncEval, numInterval]
2926+1581, +26
2927
2928!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2929! Using predefined Gauss-Kronrod 10-21 nodes and weights.
2930!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2931
2932integrand%desc
2933"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2934[abstol, reltol]
2935+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2936[lb, ub]
2937+0.00000000000000000000000000000000000, +Inf
2938
2939call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2940err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2941if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2942
2943 **** INTEGRATION FAILED: ERR = 3 ****
2944
2945getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
29463.14159265358979323846264338327950280, 3.14159265358979319764120376296608615, 0.114874526811124567747394666325693956E-14, 0.408214396203134166514689154707924291E-16 >= 1 (unbiased)? TRUE
2947[numFuncEval, numInterval]
2948+8463, +202
2949
2950integrand%desc
2951"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2952[abstol, reltol]
2953+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2954[lb, ub]
2955+0.00000000000000000000000000000000000, +Inf
2956
2957call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2958err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2959if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2960getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
29613.14159265358979323846264338327950280, 3.14159265358979323846264338382063056, 0.105513561328732570747931391478370200E-22, 0.541127766102503902738796900136909995E-27 >= 1 (unbiased)? TRUE
2962[numFuncEval, numInterval]
2963+2079, +50
2964
2965!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2966! Using predefined Gauss-Kronrod 7-15 nodes and weights.
2967!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2968
2969integrand%desc
2970"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2971[abstol, reltol]
2972+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2973[lb, ub]
2974+0.00000000000000000000000000000000000, +Inf
2975
2976call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2977err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2978if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2979
2980 **** INTEGRATION FAILED: ERR = 3 ****
2981
2982getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
29833.14159265358979323846264338327950280, 3.14159265358979318857524312405249732, 0.475502793103629506347234782922562596E-14, 0.498874002592270054729228181655556796E-16 >= 1 (unbiased)? TRUE
2984[numFuncEval, numInterval]
2985+6795, +227
2986
2987integrand%desc
2988"intDoncker1_type: f(x) = 1 / (1 + x) / sqrt(x) for x in (0 <= lb, ub) with a square-root singularity at 0"
2989[abstol, reltol]
2990+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
2991[lb, ub]
2992+0.00000000000000000000000000000000000, +Inf
2993
2994call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
2995err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
2996if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
2997getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
29983.14159265358979323846264338327950280, 3.14159265358979323846264338326012486, 0.467168906957388983973380430006517071E-24, 0.193779367284466122591080276671125047E-28 >= 1 (unbiased)? TRUE
2999[numFuncEval, numInterval]
3000+2805, +94
3001
3002
3003!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3004! int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit
3005!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3006
3007!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3008! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
3009!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3010
3011integrand%desc
3012"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3013[abstol, reltol]
3014+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3015[lb, ub]
3016+0.00000000000000000000000000000000000, +Inf
3017
3018call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3019err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3020if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3021getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3022-0.361689220620773240624502327513089541, -0.361689220620773240624502331949228571, 0.140764022682178537665750354076671096E-22, 0.443613903009769521207550217269990266E-26 >= 1 (unbiased)? TRUE
3023[numFuncEval, numInterval]
3024+19383, +137
3025
3026integrand%desc
3027"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3028[abstol, reltol]
3029+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3030[lb, ub]
3031+0.00000000000000000000000000000000000, +Inf
3032
3033call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3034err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3035if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3036getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3037-0.361689220620773240624502327513089541, -0.361689220620773240624502327513082511, 0.977613287683318626565405213831288289E-25, 0.702964429701341086365431949043498471E-32 >= 1 (unbiased)? TRUE
3038[numFuncEval, numInterval]
3039+3621, +26
3040
3041!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3042! Using predefined Gauss-Kronrod 30-61 nodes and weights.
3043!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3044
3045integrand%desc
3046"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3047[abstol, reltol]
3048+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3049[lb, ub]
3050+0.00000000000000000000000000000000000, +Inf
3051
3052call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3053err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3054if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3055getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3056-0.361689220620773240624502327513089541, -0.361689220620773240624502319791192162, 0.159802602353452815703519777127053778E-22, 0.772189737843955067973760265975410572E-26 >= 1 (unbiased)? TRUE
3057[numFuncEval, numInterval]
3058+16775, +138
3059
3060integrand%desc
3061"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3062[abstol, reltol]
3063+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3064[lb, ub]
3065+0.00000000000000000000000000000000000, +Inf
3066
3067call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3068err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3069if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3070getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3071-0.361689220620773240624502327513089541, -0.361689220620773240624502327513049963, 0.649234086107557387537554200077053878E-24, 0.395778603571576967803003467201202564E-31 >= 1 (unbiased)? TRUE
3072[numFuncEval, numInterval]
3073+3111, +26
3074
3075!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3076! Using predefined Gauss-Kronrod 25-51 nodes and weights.
3077!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3078
3079integrand%desc
3080"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3081[abstol, reltol]
3082+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3083[lb, ub]
3084+0.00000000000000000000000000000000000, +Inf
3085
3086call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3087err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3088if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3089getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3090-0.361689220620773240624502327513089541, -0.361689220620773240624502331813782684, 0.190225183222055599449587101735184091E-22, 0.430069314378555327293881155754331262E-26 >= 1 (unbiased)? TRUE
3091[numFuncEval, numInterval]
3092+14127, +139
3093
3094integrand%desc
3095"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3096[abstol, reltol]
3097+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3098[lb, ub]
3099+0.00000000000000000000000000000000000, +Inf
3100
3101call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3102err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3103if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3104getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3105-0.361689220620773240624502327513089541, -0.361689220620773240624502327512625729, 0.616335697440850490093265086774648090E-23, 0.463812078857056074312205888023015121E-30 >= 1 (unbiased)? TRUE
3106[numFuncEval, numInterval]
3107+2601, +26
3108
3109!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3110! Using predefined Gauss-Kronrod 20-41 nodes and weights.
3111!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3112
3113integrand%desc
3114"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3115[abstol, reltol]
3116+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3117[lb, ub]
3118+0.00000000000000000000000000000000000, +Inf
3119
3120call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3121err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3122if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3123getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3124-0.361689220620773240624502327513089541, -0.361689220620773240624502330835940626, 0.183435010336141480786372169713786816E-22, 0.332285108499527309465941005263610886E-26 >= 1 (unbiased)? TRUE
3125[numFuncEval, numInterval]
3126+11521, +141
3127
3128integrand%desc
3129"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3130[abstol, reltol]
3131+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3132[lb, ub]
3133+0.00000000000000000000000000000000000, +Inf
3134
3135call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3136err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3137if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3138getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3139-0.361689220620773240624502327513089541, -0.361689220620773240624502327513009566, 0.123129713909579171273974432704206176E-23, 0.799742409406799687981494840658391069E-31 >= 1 (unbiased)? TRUE
3140[numFuncEval, numInterval]
3141+2255, +28
3142
3143!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3144! Using predefined Gauss-Kronrod 15-31 nodes and weights.
3145!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3146
3147integrand%desc
3148"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3149[abstol, reltol]
3150+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3151[lb, ub]
3152+0.00000000000000000000000000000000000, +Inf
3153
3154call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3155err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3156if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3157getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3158-0.361689220620773240624502327513089541, -0.361689220620773240624502323765965863, 0.152973427311180191786037732702276322E-22, 0.374712367764931338786568773429950973E-26 >= 1 (unbiased)? TRUE
3159[numFuncEval, numInterval]
3160+8897, +144
3161
3162integrand%desc
3163"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3164[abstol, reltol]
3165+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3166[lb, ub]
3167+0.00000000000000000000000000000000000, +Inf
3168
3169call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3170err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3171if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3172getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3173-0.361689220620773240624502327513089541, -0.361689220620773240624502327513300045, 0.523164854593180308006077305057305110E-24, 0.210504142921524878739018389124532556E-30 >= 1 (unbiased)? TRUE
3174[numFuncEval, numInterval]
3175+1829, +30
3176
3177!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3178! Using predefined Gauss-Kronrod 10-21 nodes and weights.
3179!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3180
3181integrand%desc
3182"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3183[abstol, reltol]
3184+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3185[lb, ub]
3186+0.00000000000000000000000000000000000, +Inf
3187
3188call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3189err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3190if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3191getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3192-0.361689220620773240624502327513089541, -0.361689220620773240624502325479776002, 0.198942167448423160119859456769251402E-22, 0.203331353881394886570585684073514946E-26 >= 1 (unbiased)? TRUE
3193[numFuncEval, numInterval]
3194+6489, +155
3195
3196integrand%desc
3197"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3198[abstol, reltol]
3199+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3200[lb, ub]
3201+0.00000000000000000000000000000000000, +Inf
3202
3203call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3204err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3205if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3206getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3207-0.361689220620773240624502327513089541, -0.361689220620773240624502327513362589, 0.120942213086830553282194570751917128E-23, 0.273048717865500363067011272809978071E-30 >= 1 (unbiased)? TRUE
3208[numFuncEval, numInterval]
3209+1575, +38
3210
3211!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3212! Using predefined Gauss-Kronrod 7-15 nodes and weights.
3213!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3214
3215integrand%desc
3216"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3217[abstol, reltol]
3218+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3219[lb, ub]
3220+0.00000000000000000000000000000000000, +Inf
3221
3222call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3223err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3224if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3225getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3226-0.361689220620773240624502327513089541, -0.361689220620773240624502328297163210, 0.188835657839914572287490573450219404E-22, 0.784073669306497062932683647310351440E-27 >= 1 (unbiased)? TRUE
3227[numFuncEval, numInterval]
3228+7095, +237
3229
3230integrand%desc
3231"int6_type: an algebraic integrand of the form f(x) = log(x) / (1 + 100 * x**2) for x in (0, +Inf) with a singularity at the lower limit"
3232[abstol, reltol]
3233+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3234[lb, ub]
3235+0.00000000000000000000000000000000000, +Inf
3236
3237call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3238err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3239if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3240getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
3241-0.361689220620773240624502327513089541, -0.361689220620773240624502327513154733, 0.812813674080050988921058830769365322E-24, 0.651927286175079336259448533564997897E-31 >= 1 (unbiased)? TRUE
3242[numFuncEval, numInterval]
3243+2655, +89
3244
3245
3246!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3247! int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]
3248!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3249
3250!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3251! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
3252!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3253
3254integrand%desc
3255"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3256[abstol, reltol]
3257+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3258[lb, ub]
3259+0.333333333333333333333333333333333317, +Inf
3260
3261call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3262err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3263if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3264
3265 **** INTEGRATION FAILED: ERR = 2 ****
3266
3267getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
326852.7407483834714449977291997202299809, 52.7407483834714467336697552429463359, 0.488894669634109362681571266200232156E-13, 0.173594055552271635494764564158851669E-14 >= 1 (unbiased)? TRUE
3269[numFuncEval, numInterval]
3270+12851, +91
3271
3272integrand%desc
3273"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3274[abstol, reltol]
3275+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3276[lb, ub]
3277+0.333333333333333333333333333333333317, +Inf
3278
3279call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3280err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3281if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3282
3283 **** INTEGRATION FAILED: ERR = 2 ****
3284
3285getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
328652.7407483834714449977291997202299809, 52.7407483834714287782777673594775429, 0.448765576528036457791333257924729330E-13, 0.162194514323607524380041787060812155E-13 >= 1 (unbiased)? TRUE
3287[numFuncEval, numInterval]
3288+12709, +90
3289
3290integrand%desc
3291"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3292[abstol, reltol]
3293+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3294[lb, ub]
3295+0.333333333333333333333333333333333317, +Inf
3296
3297break = integrand%break
3298break
3299+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3300call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3301err = getQuadErr(getFunc, lb, pinf, abstol, reltol, nodeK, weightK, weightG, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3302if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3303getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
330452.7407483834714449977291997202299809, 52.7407483834714449977291997202264865, 0.814146221476416999401597707403176287E-22, 0.349440729109620073178476637902609213E-29 >= 1 (unbiased)? TRUE
3305[numFuncEval, numInterval]
3306+6319, +46
3307
3308!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3309! Using predefined Gauss-Kronrod 30-61 nodes and weights.
3310!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3311
3312integrand%desc
3313"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3314[abstol, reltol]
3315+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3316[lb, ub]
3317+0.333333333333333333333333333333333317, +Inf
3318
3319call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3320err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3321if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3322getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
332352.7407483834714449977291997202299809, 52.7407483834714449977294455848568891, 0.195041569891256019122465531925881143E-20, 0.245864626908145243927264958249245769E-21 >= 1 (unbiased)? TRUE
3324[numFuncEval, numInterval]
3325+16775, +138
3326
3327integrand%desc
3328"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3329[abstol, reltol]
3330+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3331[lb, ub]
3332+0.333333333333333333333333333333333317, +Inf
3333
3334call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3335err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3336if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3337getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
333852.7407483834714449977291997202299809, 52.7407483834714449977338209038270103, 0.143247623399460727305864834347060523E-20, 0.462118359702931748972754541717189512E-20 >= 1 (unbiased)? FALSE
3339[numFuncEval, numInterval]
3340+16043, +132
3341
3342integrand%desc
3343"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3344[abstol, reltol]
3345+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3346[lb, ub]
3347+0.333333333333333333333333333333333317, +Inf
3348
3349break = integrand%break
3350break
3351+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3352call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3353err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK61, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3354if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3355getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
335652.7407483834714449977291997202299809, 52.7407483834714449977291997202094151, 0.373540051030768792061629336455158314E-21, 0.205658503181446593332729548620988879E-28 >= 1 (unbiased)? TRUE
3357[numFuncEval, numInterval]
3358+5429, +46
3359
3360!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3361! Using predefined Gauss-Kronrod 25-51 nodes and weights.
3362!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3363
3364integrand%desc
3365"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3366[abstol, reltol]
3367+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3368[lb, ub]
3369+0.333333333333333333333333333333333317, +Inf
3370
3371call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3372err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3373if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3374getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
337552.7407483834714449977291997202299809, 52.7407483834714449977292032780414804, 0.279093677779235546504134563061711532E-20, 0.355781149947824961455151040990947218E-23 >= 1 (unbiased)? TRUE
3376[numFuncEval, numInterval]
3377+14433, +142
3378
3379integrand%desc
3380"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3381[abstol, reltol]
3382+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3383[lb, ub]
3384+0.333333333333333333333333333333333317, +Inf
3385
3386call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3387err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3388if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3389getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
339052.7407483834714449977291997202299809, 52.7407483834714449977293031314616029, 0.824894729143166318597466882278087464E-21, 0.103411231621975342810455514204848684E-21 >= 1 (unbiased)? TRUE
3391[numFuncEval, numInterval]
3392+14331, +141
3393
3394integrand%desc
3395"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3396[abstol, reltol]
3397+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3398[lb, ub]
3399+0.333333333333333333333333333333333317, +Inf
3400
3401break = integrand%break
3402break
3403+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3404call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3405err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK51, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3406if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3407getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
340852.7407483834714449977291997202299809, 52.7407483834714449977291997200560864, 0.221456275636688387757438582586629124E-20, 0.173894525794656789855447915609524190E-27 >= 1 (unbiased)? TRUE
3409[numFuncEval, numInterval]
3410+4539, +46
3411
3412!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3413! Using predefined Gauss-Kronrod 20-41 nodes and weights.
3414!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3415
3416integrand%desc
3417"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3418[abstol, reltol]
3419+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3420[lb, ub]
3421+0.333333333333333333333333333333333317, +Inf
3422
3423call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3424err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3425if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3426getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
342752.7407483834714449977291997202299809, 52.7407483834714449977291943591229860, 0.198270687739271790878340875560329559E-20, 0.536110699492150105020206415281175069E-23 >= 1 (unbiased)? TRUE
3428[numFuncEval, numInterval]
3429+12177, +149
3430
3431integrand%desc
3432"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3433[abstol, reltol]
3434+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3435[lb, ub]
3436+0.333333333333333333333333333333333317, +Inf
3437
3438call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3439err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3440if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3441getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
344252.7407483834714449977291997202299809, 52.7407483834714449977303444755823514, 0.280803500478789175146169405499030991E-20, 0.114475535237044669175271590495449833E-20 >= 1 (unbiased)? TRUE
3443[numFuncEval, numInterval]
3444+11767, +144
3445
3446integrand%desc
3447"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3448[abstol, reltol]
3449+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3450[lb, ub]
3451+0.333333333333333333333333333333333317, +Inf
3452
3453break = integrand%break
3454break
3455+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3456call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3457err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK41, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3458if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3459getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
346052.7407483834714449977291997202299809, 52.7407483834714449977291997202295927, 0.606149318078880650486200447633431095E-21, 0.388267476788466747976085153225121347E-30 >= 1 (unbiased)? TRUE
3461[numFuncEval, numInterval]
3462+3977, +50
3463
3464!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3465! Using predefined Gauss-Kronrod 15-31 nodes and weights.
3466!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3467
3468integrand%desc
3469"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3470[abstol, reltol]
3471+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3472[lb, ub]
3473+0.333333333333333333333333333333333317, +Inf
3474
3475call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3476err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3477if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3478getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
347952.7407483834714449977291997202299809, 52.7407483834714449977291115291164641, 0.252258108714589477704630581014850440E-20, 0.881911135168059676260410887716276442E-22 >= 1 (unbiased)? TRUE
3480[numFuncEval, numInterval]
3481+10571, +171
3482
3483integrand%desc
3484"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3485[abstol, reltol]
3486+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3487[lb, ub]
3488+0.333333333333333333333333333333333317, +Inf
3489
3490call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3491err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3492if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3493getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
349452.7407483834714449977291997202299809, 52.7407483834714449977289936196115910, 0.275731933751259902205245936226910213E-20, 0.206100618389907107855091204582988015E-21 >= 1 (unbiased)? TRUE
3495[numFuncEval, numInterval]
3496+10075, +163
3497
3498integrand%desc
3499"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3500[abstol, reltol]
3501+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3502[lb, ub]
3503+0.333333333333333333333333333333333317, +Inf
3504
3505break = integrand%break
3506break
3507+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3508call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3509err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK31, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3510if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3511getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
351252.7407483834714449977291997202299809, 52.7407483834714449977291997202297961, 0.454393419228684987713015459783569490E-23, 0.184889274661174641893373882488153023E-30 >= 1 (unbiased)? TRUE
3513[numFuncEval, numInterval]
3514+3255, +54
3515
3516!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3517! Using predefined Gauss-Kronrod 10-21 nodes and weights.
3518!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3519
3520integrand%desc
3521"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3522[abstol, reltol]
3523+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3524[lb, ub]
3525+0.333333333333333333333333333333333317, +Inf
3526
3527call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3528err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3529if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3530getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
353152.7407483834714449977291997202299809, 52.7407483834714449977292382804310509, 0.279671641778641328549215166005514544E-20, 0.385602010699552608488581761001623823E-22 >= 1 (unbiased)? TRUE
3532[numFuncEval, numInterval]
3533+9975, +238
3534
3535integrand%desc
3536"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3537[abstol, reltol]
3538+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3539[lb, ub]
3540+0.333333333333333333333333333333333317, +Inf
3541
3542call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3543err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3544if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3545getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
354652.7407483834714449977291997202299809, 52.7407483834714449977306706191554779, 0.169942945536630143394077258382982232E-20, 0.147089892549693710441322727749006848E-20 >= 1 (unbiased)? TRUE
3547[numFuncEval, numInterval]
3548+9555, +228
3549
3550integrand%desc
3551"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3552[abstol, reltol]
3553+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3554[lb, ub]
3555+0.333333333333333333333333333333333317, +Inf
3556
3557break = integrand%break
3558break
3559+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3560call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3561err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK21, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3562if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3563getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
356452.7407483834714449977291997202299809, 52.7407483834714449977291997198284384, 0.550213100585731346916629215373301014E-21, 0.401542526709139087264029397987770734E-27 >= 1 (unbiased)? TRUE
3565[numFuncEval, numInterval]
3566+2373, +58
3567
3568!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3569! Using predefined Gauss-Kronrod 7-15 nodes and weights.
3570!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3571
3572integrand%desc
3573"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3574[abstol, reltol]
3575+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3576[lb, ub]
3577+0.333333333333333333333333333333333317, +Inf
3578
3579call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3580err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3581if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3582getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
358352.7407483834714449977291997202299809, 52.7407483834714449977291834015854834, 0.283988651830937321949879077524211995E-20, 0.163186444975161969182157996535085000E-22 >= 1 (unbiased)? TRUE
3584[numFuncEval, numInterval]
3585+12045, +402
3586
3587integrand%desc
3588"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3589[abstol, reltol]
3590+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3591[lb, ub]
3592+0.333333333333333333333333333333333317, +Inf
3593
3594call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3595err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3596if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3597getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
359852.7407483834714449977291997202299809, 52.7407483834714449977288734690597645, 0.103222675119087665510261254035590240E-20, 0.326251170216414436820294717418654444E-21 >= 1 (unbiased)? TRUE
3599[numFuncEval, numInterval]
3600+11745, +392
3601
3602integrand%desc
3603"int7_type: an algebraic integrand of the form f(x) = -log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) with two singularities at [1 / sqrt(2), 1]"
3604[abstol, reltol]
3605+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3606[lb, ub]
3607+0.333333333333333333333333333333333317, +Inf
3608
3609break = integrand%break
3610break
3611+0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
3612call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3613err = getQuadErr(getFunc, lb, pinf, abstol, reltol, GK15, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3614if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3615getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
361652.7407483834714449977291997202299809, 52.7407483834714449977291997201770903, 0.467564034128253195580489341089959844E-21, 0.528906585047400258909644886504443080E-28 >= 1 (unbiased)? TRUE
3617[numFuncEval, numInterval]
3618+4245, +143
3619
3620
3621!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3622!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3623! Compare integration via:
3624! the Adaptive Global Gauss-Kronrod Quadrature method without extrapolation on a semi-infinite range `(-Inf, ub)`,
3625! with,
3626! the Adaptive Global Gauss-Kronrod Quadrature method with extrapolation on a semi-infinite range `(-Inf, ub)`.
3627!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3628!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3629
3630
3631!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3632! int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]
3633!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3634
3635!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3636! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
3637!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3638
3639integrand%desc
3640"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3641[abstol, reltol]
3642+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3643[lb, ub]
3644-Inf, -0.333333333333333333333333333333333317
3645
3646call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3647err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3648if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3649
3650 **** INTEGRATION FAILED: ERR = 2 ****
3651
3652getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
365352.7407483834714449977291997202299809, 52.7407483834714467336697552429463359, 0.488894669634109362681571266200232156E-13, 0.173594055552271635494764564158851669E-14 >= 1 (unbiased)? TRUE
3654[numFuncEval, numInterval]
3655+12851, +91
3656
3657integrand%desc
3658"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3659[abstol, reltol]
3660+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3661[lb, ub]
3662-Inf, -0.333333333333333333333333333333333317
3663
3664call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3665err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3666if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3667
3668 **** INTEGRATION FAILED: ERR = 2 ****
3669
3670getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
367152.7407483834714449977291997202299809, 52.7407483834714287782777673594775429, 0.448765576528036457791333257924729330E-13, 0.162194514323607524380041787060812155E-13 >= 1 (unbiased)? TRUE
3672[numFuncEval, numInterval]
3673+12709, +90
3674
3675integrand%desc
3676"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3677[abstol, reltol]
3678+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3679[lb, ub]
3680-Inf, -0.333333333333333333333333333333333317
3681
3682break = integrand%break
3683break
3684-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3685call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3686err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3687if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3688getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
368952.7407483834714449977291997202299809, 52.7407483834714449977291997202264865, 0.814146221476416999401597707403176287E-22, 0.349440729109620073178476637902609213E-29 >= 1 (unbiased)? TRUE
3690[numFuncEval, numInterval]
3691+6319, +46
3692
3693!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3694! Using predefined Gauss-Kronrod 30-61 nodes and weights.
3695!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3696
3697integrand%desc
3698"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3699[abstol, reltol]
3700+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3701[lb, ub]
3702-Inf, -0.333333333333333333333333333333333317
3703
3704call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3705err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3706if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3707getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
370852.7407483834714449977291997202299809, 52.7407483834714449977294455848568891, 0.195041569891256019122465531925881143E-20, 0.245864626908145243927264958249245769E-21 >= 1 (unbiased)? TRUE
3709[numFuncEval, numInterval]
3710+16775, +138
3711
3712integrand%desc
3713"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3714[abstol, reltol]
3715+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3716[lb, ub]
3717-Inf, -0.333333333333333333333333333333333317
3718
3719call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3720err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3721if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3722getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
372352.7407483834714449977291997202299809, 52.7407483834714449977338209038270103, 0.143247623399460727305864834347060523E-20, 0.462118359702931748972754541717189512E-20 >= 1 (unbiased)? FALSE
3724[numFuncEval, numInterval]
3725+16043, +132
3726
3727integrand%desc
3728"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3729[abstol, reltol]
3730+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3731[lb, ub]
3732-Inf, -0.333333333333333333333333333333333317
3733
3734break = integrand%break
3735break
3736-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3737call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3738err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3739if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3740getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
374152.7407483834714449977291997202299809, 52.7407483834714449977291997202094151, 0.373540051030768792061629336455158314E-21, 0.205658503181446593332729548620988879E-28 >= 1 (unbiased)? TRUE
3742[numFuncEval, numInterval]
3743+5429, +46
3744
3745!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3746! Using predefined Gauss-Kronrod 25-51 nodes and weights.
3747!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3748
3749integrand%desc
3750"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3751[abstol, reltol]
3752+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3753[lb, ub]
3754-Inf, -0.333333333333333333333333333333333317
3755
3756call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3757err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3758if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3759getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
376052.7407483834714449977291997202299809, 52.7407483834714449977292032780414804, 0.279093677779235546504134563061711532E-20, 0.355781149947824961455151040990947218E-23 >= 1 (unbiased)? TRUE
3761[numFuncEval, numInterval]
3762+14433, +142
3763
3764integrand%desc
3765"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3766[abstol, reltol]
3767+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3768[lb, ub]
3769-Inf, -0.333333333333333333333333333333333317
3770
3771call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3772err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3773if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3774getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
377552.7407483834714449977291997202299809, 52.7407483834714449977293031314616029, 0.824894729143166318597466882278087464E-21, 0.103411231621975342810455514204848684E-21 >= 1 (unbiased)? TRUE
3776[numFuncEval, numInterval]
3777+14331, +141
3778
3779integrand%desc
3780"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3781[abstol, reltol]
3782+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3783[lb, ub]
3784-Inf, -0.333333333333333333333333333333333317
3785
3786break = integrand%break
3787break
3788-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3789call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3790err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3791if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3792getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
379352.7407483834714449977291997202299809, 52.7407483834714449977291997200560864, 0.221456275636688387757438582586629124E-20, 0.173894525794656789855447915609524190E-27 >= 1 (unbiased)? TRUE
3794[numFuncEval, numInterval]
3795+4539, +46
3796
3797!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3798! Using predefined Gauss-Kronrod 20-41 nodes and weights.
3799!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3800
3801integrand%desc
3802"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3803[abstol, reltol]
3804+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3805[lb, ub]
3806-Inf, -0.333333333333333333333333333333333317
3807
3808call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3809err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3810if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3811getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
381252.7407483834714449977291997202299809, 52.7407483834714449977291943591229860, 0.198270687739271790878340875560329559E-20, 0.536110699492150105020206415281175069E-23 >= 1 (unbiased)? TRUE
3813[numFuncEval, numInterval]
3814+12177, +149
3815
3816integrand%desc
3817"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3818[abstol, reltol]
3819+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3820[lb, ub]
3821-Inf, -0.333333333333333333333333333333333317
3822
3823call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3824err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3825if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3826getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
382752.7407483834714449977291997202299809, 52.7407483834714449977303444755823514, 0.280803500478789175146169405499030991E-20, 0.114475535237044669175271590495449833E-20 >= 1 (unbiased)? TRUE
3828[numFuncEval, numInterval]
3829+11767, +144
3830
3831integrand%desc
3832"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3833[abstol, reltol]
3834+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3835[lb, ub]
3836-Inf, -0.333333333333333333333333333333333317
3837
3838break = integrand%break
3839break
3840-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3841call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3842err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3843if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3844getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
384552.7407483834714449977291997202299809, 52.7407483834714449977291997202295927, 0.606149318078880650486200447633431095E-21, 0.388267476788466747976085153225121347E-30 >= 1 (unbiased)? TRUE
3846[numFuncEval, numInterval]
3847+3977, +50
3848
3849!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3850! Using predefined Gauss-Kronrod 15-31 nodes and weights.
3851!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3852
3853integrand%desc
3854"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3855[abstol, reltol]
3856+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3857[lb, ub]
3858-Inf, -0.333333333333333333333333333333333317
3859
3860call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3861err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3862if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3863getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
386452.7407483834714449977291997202299809, 52.7407483834714449977291115291164641, 0.252258108714589477704630581014850440E-20, 0.881911135168059676260410887716276442E-22 >= 1 (unbiased)? TRUE
3865[numFuncEval, numInterval]
3866+10571, +171
3867
3868integrand%desc
3869"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3870[abstol, reltol]
3871+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3872[lb, ub]
3873-Inf, -0.333333333333333333333333333333333317
3874
3875call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3876err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3877if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3878getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
387952.7407483834714449977291997202299809, 52.7407483834714449977289936196115910, 0.275731933751259902205245936226910213E-20, 0.206100618389907107855091204582988015E-21 >= 1 (unbiased)? TRUE
3880[numFuncEval, numInterval]
3881+10075, +163
3882
3883integrand%desc
3884"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3885[abstol, reltol]
3886+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3887[lb, ub]
3888-Inf, -0.333333333333333333333333333333333317
3889
3890break = integrand%break
3891break
3892-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3893call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3894err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3895if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3896getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
389752.7407483834714449977291997202299809, 52.7407483834714449977291997202297961, 0.454393419228684987713015459783569490E-23, 0.184889274661174641893373882488153023E-30 >= 1 (unbiased)? TRUE
3898[numFuncEval, numInterval]
3899+3255, +54
3900
3901!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3902! Using predefined Gauss-Kronrod 10-21 nodes and weights.
3903!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3904
3905integrand%desc
3906"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3907[abstol, reltol]
3908+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3909[lb, ub]
3910-Inf, -0.333333333333333333333333333333333317
3911
3912call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3913err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3914if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3915getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
391652.7407483834714449977291997202299809, 52.7407483834714449977292382804310509, 0.279671641778641328549215166005514544E-20, 0.385602010699552608488581761001623823E-22 >= 1 (unbiased)? TRUE
3917[numFuncEval, numInterval]
3918+9975, +238
3919
3920integrand%desc
3921"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3922[abstol, reltol]
3923+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3924[lb, ub]
3925-Inf, -0.333333333333333333333333333333333317
3926
3927call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3928err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3929if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3930getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
393152.7407483834714449977291997202299809, 52.7407483834714449977306706191554779, 0.169942945536630143394077258382982232E-20, 0.147089892549693710441322727749006848E-20 >= 1 (unbiased)? TRUE
3932[numFuncEval, numInterval]
3933+9555, +228
3934
3935integrand%desc
3936"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3937[abstol, reltol]
3938+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3939[lb, ub]
3940-Inf, -0.333333333333333333333333333333333317
3941
3942break = integrand%break
3943break
3944-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3945call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3946err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3947if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3948getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
394952.7407483834714449977291997202299809, 52.7407483834714449977291997198284384, 0.550213100585731346916629215373301014E-21, 0.401542526709139087264029397987770734E-27 >= 1 (unbiased)? TRUE
3950[numFuncEval, numInterval]
3951+2373, +58
3952
3953!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3954! Using predefined Gauss-Kronrod 7-15 nodes and weights.
3955!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3956
3957integrand%desc
3958"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3959[abstol, reltol]
3960+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3961[lb, ub]
3962-Inf, -0.333333333333333333333333333333333317
3963
3964call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3965err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3966if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3967getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
396852.7407483834714449977291997202299809, 52.7407483834714449977291834015854834, 0.283988651830937321949879077524211995E-20, 0.163186444975161969182157996535085000E-22 >= 1 (unbiased)? TRUE
3969[numFuncEval, numInterval]
3970+12045, +402
3971
3972integrand%desc
3973"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3974[abstol, reltol]
3975+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3976[lb, ub]
3977-Inf, -0.333333333333333333333333333333333317
3978
3979call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3980err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3981if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
3982getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
398352.7407483834714449977291997202299809, 52.7407483834714449977288734690597645, 0.103222675119087665510261254035590240E-20, 0.326251170216414436820294717418654444E-21 >= 1 (unbiased)? TRUE
3984[numFuncEval, numInterval]
3985+11745, +392
3986
3987integrand%desc
3988"int8_type: an algebraic integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (-Inf, -1./3.) with two singularities at [-1, -1 / sqrt(2)]"
3989[abstol, reltol]
3990+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
3991[lb, ub]
3992-Inf, -0.333333333333333333333333333333333317
3993
3994break = integrand%break
3995break
3996-1.00000000000000000000000000000000000, -0.707106781186547524400844362104849088
3997call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
3998err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
3999if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4000getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
400152.7407483834714449977291997202299809, 52.7407483834714449977291997201770903, 0.467564034128253195580489341089959844E-21, 0.528906585047400258909644886504443080E-28 >= 1 (unbiased)? TRUE
4002[numFuncEval, numInterval]
4003+4245, +143
4004
4005
4006!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4007! intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0
4008!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4009
4010!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4011! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
4012!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4013
4014integrand%desc
4015"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4016[abstol, reltol]
4017+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4018[lb, ub]
4019-Inf, +0.00000000000000000000000000000000000
4020
4021call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4022err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4023if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4024
4025 **** INTEGRATION FAILED: ERR = 3 ****
4026
4027getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
40281.77245385090551602729816748334114514, 1.77245385090551601613820286109549568, 0.877575963278399810921822968544910165E-15, 0.111599646222456494583191882286173036E-16 >= 1 (unbiased)? TRUE
4029[numFuncEval, numInterval]
4030+14271, +101
4031
4032integrand%desc
4033"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4034[abstol, reltol]
4035+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4036[lb, ub]
4037-Inf, +0.00000000000000000000000000000000000
4038
4039call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4040err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4041if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4042getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
40431.77245385090551602729816748334114514, 1.77245385090551602729816748336857327, 0.134737402993443930374494505735777631E-22, 0.274281313029908194012967098693232424E-28 >= 1 (unbiased)? TRUE
4044[numFuncEval, numInterval]
4045+2059, +15
4046
4047!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4048! Using predefined Gauss-Kronrod 30-61 nodes and weights.
4049!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4050
4051integrand%desc
4052"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4053[abstol, reltol]
4054+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4055[lb, ub]
4056-Inf, +0.00000000000000000000000000000000000
4057
4058call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4059err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4060if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4061
4062 **** INTEGRATION FAILED: ERR = 3 ****
4063
4064getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
40651.77245385090551602729816748334114514, 1.77245385090551601810714679211041636, 0.861478851009438123585806814388995306E-15, 0.919102069123072878047958986460957030E-17 >= 1 (unbiased)? TRUE
4066[numFuncEval, numInterval]
4067+12383, +102
4068
4069integrand%desc
4070"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4071[abstol, reltol]
4072+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4073[lb, ub]
4074-Inf, +0.00000000000000000000000000000000000
4075
4076call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4077err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4078if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4079getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
40801.77245385090551602729816748334114514, 1.77245385090551602729816748333337247, 0.674662220972954240186456842964833718E-22, 0.777266806955800645576331578068424967E-29 >= 1 (unbiased)? TRUE
4081[numFuncEval, numInterval]
4082+1769, +15
4083
4084!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4085! Using predefined Gauss-Kronrod 25-51 nodes and weights.
4086!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4087
4088integrand%desc
4089"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4090[abstol, reltol]
4091+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4092[lb, ub]
4093-Inf, +0.00000000000000000000000000000000000
4094
4095call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4096err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4097if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4098
4099 **** INTEGRATION FAILED: ERR = 3 ****
4100
4101getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
41021.77245385090551602729816748334114514, 1.77245385090551601574298708775896303, 0.857230920014370223618121336117106411E-15, 0.115551803955821821140929648821560637E-16 >= 1 (unbiased)? TRUE
4103[numFuncEval, numInterval]
4104+10353, +102
4105
4106integrand%desc
4107"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4108[abstol, reltol]
4109+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4110[lb, ub]
4111-Inf, +0.00000000000000000000000000000000000
4112
4113call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4114err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4115if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4116getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
41171.77245385090551602729816748334114514, 1.77245385090551602729816748386972220, 0.118234663994776709095004812810198545E-22, 0.528577058433915602855187008678466799E-27 >= 1 (unbiased)? TRUE
4118[numFuncEval, numInterval]
4119+1581, +16
4120
4121!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4122! Using predefined Gauss-Kronrod 20-41 nodes and weights.
4123!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4124
4125integrand%desc
4126"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4127[abstol, reltol]
4128+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4129[lb, ub]
4130-Inf, +0.00000000000000000000000000000000000
4131
4132call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4133err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4134if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4135
4136 **** INTEGRATION FAILED: ERR = 3 ****
4137
4138getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
41391.77245385090551602729816748334114514, 1.77245385090551601064340064620432546, 0.845367076234297452274336535948441536E-15, 0.166547668371368196815771814538113779E-16 >= 1 (unbiased)? TRUE
4140[numFuncEval, numInterval]
4141+8405, +103
4142
4143integrand%desc
4144"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4145[abstol, reltol]
4146+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4147[lb, ub]
4148-Inf, +0.00000000000000000000000000000000000
4149
4150call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4151err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4152if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4153getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
41541.77245385090551602729816748334114514, 1.77245385090551602729816748332323553, 0.377961853986480130862622013707784937E-23, 0.179096077388457836447381500836857561E-28 >= 1 (unbiased)? TRUE
4155[numFuncEval, numInterval]
4156+1435, +18
4157
4158!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4159! Using predefined Gauss-Kronrod 15-31 nodes and weights.
4160!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4161
4162integrand%desc
4163"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4164[abstol, reltol]
4165+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4166[lb, ub]
4167-Inf, +0.00000000000000000000000000000000000
4168
4169call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4170err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4171if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4172
4173 **** INTEGRATION FAILED: ERR = 3 ****
4174
4175getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
41761.77245385090551602729816748334114514, 1.77245385090551601376368098397951221, 0.590274422370976543075513404981098544E-15, 0.135344864993616329326924625808078389E-16 >= 1 (unbiased)? TRUE
4177[numFuncEval, numInterval]
4178+6479, +105
4179
4180integrand%desc
4181"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4182[abstol, reltol]
4183+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4184[lb, ub]
4185-Inf, +0.00000000000000000000000000000000000
4186
4187call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4188err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4189if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4190getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
41911.77245385090551602729816748334114514, 1.77245385090551602729816748332697087, 0.439536242587639020103894082379843368E-22, 0.141742666117067397077360808640422896E-28 >= 1 (unbiased)? TRUE
4192[numFuncEval, numInterval]
4193+1147, +19
4194
4195!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4196! Using predefined Gauss-Kronrod 10-21 nodes and weights.
4197!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4198
4199integrand%desc
4200"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4201[abstol, reltol]
4202+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4203[lb, ub]
4204-Inf, +0.00000000000000000000000000000000000
4205
4206call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4207err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4208if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4209
4210 **** INTEGRATION FAILED: ERR = 3 ****
4211
4212getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
42131.77245385090551602729816748334114514, 1.77245385090551600687177993068626502, 0.574360549312137963665679582228894917E-15, 0.204263875526548801162109406012147667E-16 >= 1 (unbiased)? TRUE
4214[numFuncEval, numInterval]
4215+4431, +106
4216
4217integrand%desc
4218"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4219[abstol, reltol]
4220+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4221[lb, ub]
4222-Inf, +0.00000000000000000000000000000000000
4223
4224call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4225err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4226if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4227getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
42281.77245385090551602729816748334114514, 1.77245385090551602729816748299131749, 0.741255376788311540853126588333374290E-22, 0.349827648435447468861355583871274525E-27 >= 1 (unbiased)? TRUE
4229[numFuncEval, numInterval]
4230+1491, +36
4231
4232!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4233! Using predefined Gauss-Kronrod 7-15 nodes and weights.
4234!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4235
4236integrand%desc
4237"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4238[abstol, reltol]
4239+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4240[lb, ub]
4241-Inf, +0.00000000000000000000000000000000000
4242
4243call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4244err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4245if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4246
4247 **** INTEGRATION FAILED: ERR = 3 ****
4248
4249getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
42501.77245385090551602729816748334114514, 1.77245385090551600609844209961646132, 0.235414966530662165086749026544244634E-14, 0.211997253837246838222909559709411589E-16 >= 1 (unbiased)? TRUE
4251[numFuncEval, numInterval]
4252+3675, +123
4253
4254integrand%desc
4255"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4256[abstol, reltol]
4257+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4258[lb, ub]
4259-Inf, +0.00000000000000000000000000000000000
4260
4261call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4262err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4263if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4264getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
42651.77245385090551602729816748334114514, 1.77245385090551602729816748335898310, 0.615529072454046125320330530748558927E-22, 0.178379631449145784710044677042215968E-28 >= 1 (unbiased)? TRUE
4266[numFuncEval, numInterval]
4267+2025, +68
4268
4269
4270!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4271! intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0
4272!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4273
4274!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4275! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
4276!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4277
4278integrand%desc
4279"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4280[abstol, reltol]
4281+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4282[lb, ub]
4283-Inf, -1.00000000000000000000000000000000000
4284
4285call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4286err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4287if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4288getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
42890.278805585280661976499232611077439155, 0.278805585280661976499232611077439348, 0.716856891023470741140679322036923946E-29, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
4290[numFuncEval, numInterval]
4291+497, +4
4292
4293integrand%desc
4294"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4295[abstol, reltol]
4296+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4297[lb, ub]
4298-Inf, -1.00000000000000000000000000000000000
4299
4300call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4301err = getQuadErr(getFunc, ninf, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4302if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4303getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
43040.278805585280661976499232611077439155, 0.278805585280661976499232611077439348, 0.716856891023470741140679322036923946E-29, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
4305[numFuncEval, numInterval]
4306+497, +4
4307
4308!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4309! Using predefined Gauss-Kronrod 30-61 nodes and weights.
4310!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4311
4312integrand%desc
4313"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4314[abstol, reltol]
4315+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4316[lb, ub]
4317-Inf, -1.00000000000000000000000000000000000
4318
4319call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4320err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4321if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4322getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
43230.278805585280661976499232611077439155, 0.278805585280661976499232611077607915, 0.151355225479325107963069113063096090E-25, 0.168759611376931541624030067219004256E-30 >= 1 (unbiased)? TRUE
4324[numFuncEval, numInterval]
4325+427, +4
4326
4327integrand%desc
4328"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4329[abstol, reltol]
4330+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4331[lb, ub]
4332-Inf, -1.00000000000000000000000000000000000
4333
4334call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4335err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4336if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4337getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
43380.278805585280661976499232611077439155, 0.278805585280661976499232611077607915, 0.151355225479325107963069113063096090E-25, 0.168759611376931541624030067219004256E-30 >= 1 (unbiased)? TRUE
4339[numFuncEval, numInterval]
4340+427, +4
4341
4342!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4343! Using predefined Gauss-Kronrod 25-51 nodes and weights.
4344!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4345
4346integrand%desc
4347"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4348[abstol, reltol]
4349+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4350[lb, ub]
4351-Inf, -1.00000000000000000000000000000000000
4352
4353call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4354err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4355if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4356getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
43570.278805585280661976499232611077439155, 0.278805585280661976499232611077439155, 0.352179410496721019887485283057483945E-29, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
4358[numFuncEval, numInterval]
4359+459, +5
4360
4361integrand%desc
4362"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4363[abstol, reltol]
4364+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4365[lb, ub]
4366-Inf, -1.00000000000000000000000000000000000
4367
4368call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4369err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4370if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4371getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
43720.278805585280661976499232611077439155, 0.278805585280661976499232611077439155, 0.352179410496721019887485283057483945E-29, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
4373[numFuncEval, numInterval]
4374+459, +5
4375
4376!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4377! Using predefined Gauss-Kronrod 20-41 nodes and weights.
4378!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4379
4380integrand%desc
4381"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4382[abstol, reltol]
4383+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4384[lb, ub]
4385-Inf, -1.00000000000000000000000000000000000
4386
4387call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4388err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4389if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4390getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
43910.278805585280661976499232611077439155, 0.278805585280661976499232611077413059, 0.123546587340256886697721158475102482E-24, 0.260963507464470458089085011220257652E-31 >= 1 (unbiased)? TRUE
4392[numFuncEval, numInterval]
4393+369, +5
4394
4395integrand%desc
4396"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4397[abstol, reltol]
4398+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4399[lb, ub]
4400-Inf, -1.00000000000000000000000000000000000
4401
4402call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4403err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4404if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4405getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
44060.278805585280661976499232611077439155, 0.278805585280661976499232611077413059, 0.123546587340256886697721158475102482E-24, 0.260963507464470458089085011220257652E-31 >= 1 (unbiased)? TRUE
4407[numFuncEval, numInterval]
4408+369, +5
4409
4410!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4411! Using predefined Gauss-Kronrod 15-31 nodes and weights.
4412!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4413
4414integrand%desc
4415"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4416[abstol, reltol]
4417+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4418[lb, ub]
4419-Inf, -1.00000000000000000000000000000000000
4420
4421call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4422err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4423if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4424getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
44250.278805585280661976499232611077439155, 0.278805585280661976499232611077439155, 0.638822419200203188163935077576414827E-27, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
4426[numFuncEval, numInterval]
4427+341, +6
4428
4429integrand%desc
4430"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4431[abstol, reltol]
4432+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4433[lb, ub]
4434-Inf, -1.00000000000000000000000000000000000
4435
4436call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4437err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4438if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4439getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
44400.278805585280661976499232611077439155, 0.278805585280661976499232611077439155, 0.638822419200203188163935077576414827E-27, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
4441[numFuncEval, numInterval]
4442+341, +6
4443
4444!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4445! Using predefined Gauss-Kronrod 10-21 nodes and weights.
4446!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4447
4448integrand%desc
4449"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4450[abstol, reltol]
4451+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4452[lb, ub]
4453-Inf, -1.00000000000000000000000000000000000
4454
4455call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4456err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4457if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4458getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
44590.278805585280661976499232611077439155, 0.278805585280661976499232611077447244, 0.136847162139771908855491210817521382E-24, 0.808890576642639058283510735885669474E-32 >= 1 (unbiased)? TRUE
4460[numFuncEval, numInterval]
4461+441, +11
4462
4463integrand%desc
4464"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4465[abstol, reltol]
4466+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4467[lb, ub]
4468-Inf, -1.00000000000000000000000000000000000
4469
4470call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4471err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4472if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4473getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
44740.278805585280661976499232611077439155, 0.278805585280661976499232611077447292, 0.136847162139771908864182157536569162E-24, 0.813705401503607147916150680742131792E-32 >= 1 (unbiased)? TRUE
4475[numFuncEval, numInterval]
4476+441, +11
4477
4478!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4479! Using predefined Gauss-Kronrod 7-15 nodes and weights.
4480!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4481
4482integrand%desc
4483"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4484[abstol, reltol]
4485+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4486[lb, ub]
4487-Inf, -1.00000000000000000000000000000000000
4488
4489call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4490err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4491if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4492getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
44930.278805585280661976499232611077439155, 0.278805585280661976499232611077440600, 0.908293983528496004117130980367892813E-23, 0.144444745829042688979198345693869549E-32 >= 1 (unbiased)? TRUE
4494[numFuncEval, numInterval]
4495+645, +22
4496
4497integrand%desc
4498"intDoncker2_type: f(x) = exp(x) / sqrt(-x) for x in (lb, ub <= 0) with a square-root singularity at 0"
4499[abstol, reltol]
4500+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4501[lb, ub]
4502-Inf, -1.00000000000000000000000000000000000
4503
4504call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4505err = getQuadErr(getFunc, ninf, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4506if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4507getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
45080.278805585280661976499232611077439155, 0.278805585280661976499232611077440552, 0.908293983528495999905253519959137847E-23, 0.139629920968074599346558400837407231E-32 >= 1 (unbiased)? TRUE
4509[numFuncEval, numInterval]
4510+645, +22
4511
4512
4513!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4514!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4515! Compare integration via:
4516! the Adaptive Global Gauss-Kronrod Quadrature method without extrapolation on a full-infinite range `(-Inf, +Inf)`,
4517! with,
4518! the Adaptive Global Gauss-Kronrod Quadrature method with extrapolation on a full-infinite range `(-Inf, +Inf)`.
4519!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4520!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4521
4522
4523!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4524! int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]
4525!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4526
4527!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4528! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
4529!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4530
4531integrand%desc
4532"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4533[abstol, reltol]
4534+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4535[lb, ub]
4536-Inf, +Inf
4537
4538call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4539err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4540if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4541
4542 **** INTEGRATION FAILED: ERR = 3 ****
4543
4544getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
454553.7407483834714449977291997202299809, 53.7407483834714449650072940561829495, 0.796822065622794229045441469278186467E-14, 0.327219056640470314173818584982640383E-16 >= 1 (unbiased)? TRUE
4546[numFuncEval, numInterval]
4547+48351, +341
4548
4549integrand%desc
4550"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4551[abstol, reltol]
4552+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4553[lb, ub]
4554-Inf, +Inf
4555
4556call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4557err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4558if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4559
4560 **** INTEGRATION FAILED: ERR = 4 ****
4561
4562getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
456353.7407483834714449977291997202299809, 53.7407483834705929661166935183967571, 0.124399652525198607918270581145824005E-10, 0.852031612506201833223899482873825881E-12 >= 1 (unbiased)? TRUE
4564[numFuncEval, numInterval]
4565+33725, +238
4566
4567integrand%desc
4568"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4569[abstol, reltol]
4570+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4571[lb, ub]
4572-Inf, +Inf
4573
4574break = integrand%break
4575break
4576-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4577call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4578err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4579if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4580getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
458153.7407483834714449977291997202299809, 53.7407483834714449977291997030223177, 0.445312847511661742860075782047728754E-23, 0.172076632816429900384804965805606506E-25 >= 1 (unbiased)? TRUE
4582[numFuncEval, numInterval]
4583+14626, +106
4584
4585!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4586! Using predefined Gauss-Kronrod 30-61 nodes and weights.
4587!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4588
4589integrand%desc
4590"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4591[abstol, reltol]
4592+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4593[lb, ub]
4594-Inf, +Inf
4595
4596call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4597err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4598if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4599
4600 **** INTEGRATION FAILED: ERR = 3 ****
4601
4602getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
460353.7407483834714449977291997202299809, 53.7407483834714448833633777417907816, 0.680914645200171218811820529787362403E-14, 0.114365821978439199372589194727729117E-15 >= 1 (unbiased)? TRUE
4604[numFuncEval, numInterval]
4605+41541, +341
4606
4607integrand%desc
4608"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4609[abstol, reltol]
4610+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4611[lb, ub]
4612-Inf, +Inf
4613
4614call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4615err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4616if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4617getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
461853.7407483834714449977291997202299809, 53.7407483834714449977289348585276314, 0.170439151372582101480194610681781850E-20, 0.264861702349597177797536235127872662E-21 >= 1 (unbiased)? TRUE
4619[numFuncEval, numInterval]
4620+44835, +368
4621
4622integrand%desc
4623"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4624[abstol, reltol]
4625+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4626[lb, ub]
4627-Inf, +Inf
4628
4629break = integrand%break
4630break
4631-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4632call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4633err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4634if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4635getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
463653.7407483834714449977291997202299809, 53.7407483834714449977291997799636319, 0.200846303193510868396480563993536245E-22, 0.597336509160071589144727174273780860E-25 >= 1 (unbiased)? TRUE
4637[numFuncEval, numInterval]
4638+12566, +106
4639
4640!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4641! Using predefined Gauss-Kronrod 25-51 nodes and weights.
4642!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4643
4644integrand%desc
4645"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4646[abstol, reltol]
4647+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4648[lb, ub]
4649-Inf, +Inf
4650
4651call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4652err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4653if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4654
4655 **** INTEGRATION FAILED: ERR = 3 ****
4656
4657getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
465853.7407483834714449977291997202299809, 53.7407483834714448768004039231121724, 0.522743403161741812977518136396828071E-14, 0.120928795797117808575570243510062447E-15 >= 1 (unbiased)? TRUE
4659[numFuncEval, numInterval]
4660+35547, +349
4661
4662integrand%desc
4663"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4664[abstol, reltol]
4665+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4666[lb, ub]
4667-Inf, +Inf
4668
4669call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4670err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4671if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4672
4673 **** INTEGRATION FAILED: ERR = 4 ****
4674
4675getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
467653.7407483834714449977291997202299809, 53.7407483834728334242795656190601898, 0.392766057193472596062746488440736927E-10, 0.138842655036589883020880017029847229E-11 >= 1 (unbiased)? TRUE
4677[numFuncEval, numInterval]
4678+25245, +248
4679
4680integrand%desc
4681"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4682[abstol, reltol]
4683+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4684[lb, ub]
4685-Inf, +Inf
4686
4687break = integrand%break
4688break
4689-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4690call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4691err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4692if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4693getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
469453.7407483834714449977291997202299809, 53.7407483834714449977291997092084046, 0.115363502086247706555964249396062612E-21, 0.110215763002711884784646954289778641E-25 >= 1 (unbiased)? TRUE
4695[numFuncEval, numInterval]
4696+10506, +106
4697
4698!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4699! Using predefined Gauss-Kronrod 20-41 nodes and weights.
4700!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4701
4702integrand%desc
4703"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4704[abstol, reltol]
4705+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4706[lb, ub]
4707-Inf, +Inf
4708
4709call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4710err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4711if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4712
4713 **** INTEGRATION FAILED: ERR = 3 ****
4714
4715getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
471653.7407483834714449977291997202299809, 53.7407483834714450553835820752184976, 0.565194869440131705838502815008547290E-14, 0.576543823549885166081717509327429166E-16 >= 1 (unbiased)? TRUE
4717[numFuncEval, numInterval]
4718+29069, +355
4719
4720integrand%desc
4721"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4722[abstol, reltol]
4723+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4724[lb, ub]
4725-Inf, +Inf
4726
4727call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4728err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4729if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4730
4731 **** INTEGRATION FAILED: ERR = 4 ****
4732
4733getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
473453.7407483834714449977291997202299809, 53.7407483834714449977378930826171726, 0.470836589493817339712596777175112422E-20, 0.869336238719164342712203203722627274E-20 >= 1 (unbiased)? FALSE
4735[numFuncEval, numInterval]
4736+32103, +392
4737
4738integrand%desc
4739"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4740[abstol, reltol]
4741+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4742[lb, ub]
4743-Inf, +Inf
4744
4745break = integrand%break
4746break
4747-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4748call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4749err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4750if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4751getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
475253.7407483834714449977291997202299809, 53.7407483834714449977291997518872094, 0.100768392585712648319953445782223227E-20, 0.316572284825762632782071287108454460E-25 >= 1 (unbiased)? TRUE
4753[numFuncEval, numInterval]
4754+8446, +106
4755
4756!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4757! Using predefined Gauss-Kronrod 15-31 nodes and weights.
4758!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4759
4760integrand%desc
4761"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4762[abstol, reltol]
4763+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4764[lb, ub]
4765-Inf, +Inf
4766
4767call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4768err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4769if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4770
4771 **** INTEGRATION FAILED: ERR = 3 ****
4772
4773getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
477453.7407483834714449977291997202299809, 53.7407483834714446541590982340824365, 0.788730091829859198402913015366033236E-14, 0.343570101486147544414568939943794393E-15 >= 1 (unbiased)? TRUE
4775[numFuncEval, numInterval]
4776+22351, +361
4777
4778integrand%desc
4779"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4780[abstol, reltol]
4781+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4782[lb, ub]
4783-Inf, +Inf
4784
4785call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4786err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4787if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4788
4789 **** INTEGRATION FAILED: ERR = 4 ****
4790
4791getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
479253.7407483834714449977291997202299809, 53.7407483834714449977250233829698854, 0.307404779965835965408111286811772367E-20, 0.417633726009553582562893478054756863E-20 >= 1 (unbiased)? FALSE
4793[numFuncEval, numInterval]
4794+26691, +431
4795
4796integrand%desc
4797"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4798[abstol, reltol]
4799+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4800[lb, ub]
4801-Inf, +Inf
4802
4803break = integrand%break
4804break
4805-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4806call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4807err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4808if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4809getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
481053.7407483834714449977291997202299809, 53.7407483834714449977291996841603946, 0.493361842979613484863614903286339141E-21, 0.360695863704619079503735772999075528E-25 >= 1 (unbiased)? TRUE
4811[numFuncEval, numInterval]
4812+6758, +112
4813
4814!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4815! Using predefined Gauss-Kronrod 10-21 nodes and weights.
4816!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4817
4818integrand%desc
4819"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4820[abstol, reltol]
4821+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4822[lb, ub]
4823-Inf, +Inf
4824
4825call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4826err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4827if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4828
4829 **** INTEGRATION FAILED: ERR = 3 ****
4830
4831getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
483253.7407483834714449977291997202299809, 53.7407483834714446968169568664147327, 0.297103187254200474475915711578675253E-14, 0.300912242853815248241860288447560029E-15 >= 1 (unbiased)? TRUE
4833[numFuncEval, numInterval]
4834+19593, +467
4835
4836integrand%desc
4837"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4838[abstol, reltol]
4839+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4840[lb, ub]
4841-Inf, +Inf
4842
4843call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4844err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4845if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4846
4847 **** INTEGRATION FAILED: ERR = 4 ****
4848
4849getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
485053.7407483834714449977291997202299809, 53.7407483834714786408368937855885806, 0.597341489232740359096544257423059064E-12, 0.336431076940653585996463319794115881E-13 >= 1 (unbiased)? TRUE
4851[numFuncEval, numInterval]
4852+16401, +391
4853
4854integrand%desc
4855"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4856[abstol, reltol]
4857+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4858[lb, ub]
4859-Inf, +Inf
4860
4861break = integrand%break
4862break
4863-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4864call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4865err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4866if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4867getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
486853.7407483834714449977291997202299809, 53.7407483834714449977291998166218009, 0.511114386743455704132658170766066952E-22, 0.963918199664012722590043909239278414E-25 >= 1 (unbiased)? TRUE
4869[numFuncEval, numInterval]
4870+5544, +135
4871
4872!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4873! Using predefined Gauss-Kronrod 7-15 nodes and weights.
4874!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4875
4876integrand%desc
4877"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4878[abstol, reltol]
4879+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4880[lb, ub]
4881-Inf, +Inf
4882
4883call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4884err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4885if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4886
4887 **** INTEGRATION FAILED: ERR = 3 ****
4888
4889getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
489053.7407483834714449977291997202299809, 53.7407483834714446236379151155632889, 0.105265306858749509467041399734121873E-13, 0.374091284604666692075516754298534578E-15 >= 1 (unbiased)? TRUE
4891[numFuncEval, numInterval]
4892+14685, +490
4893
4894integrand%desc
4895"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4896[abstol, reltol]
4897+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4898[lb, ub]
4899-Inf, +Inf
4900
4901call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4902err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4903if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4904getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
490553.7407483834714449977291997202299809, 53.7407483834714449977276451874018056, 0.222587462272588358893891703394271234E-20, 0.155453282817532481191470919240630327E-20 >= 1 (unbiased)? TRUE
4906[numFuncEval, numInterval]
4907+24885, +830
4908
4909integrand%desc
4910"int9_type: an algebraic piecewise integrand of the form f(x) = log(abs((1 - x**2) * (1 - 2 * x**2)) / x**4) / x**5 for x in (1./3., +Inf) and 1 / (acos(-1) * sqrt(-(x+10) * (x+9))) for x in (-10, 9), otherwise 0, with two singularities at [-10, -9, 1/3., 1 / sqrt(2), 1]"
4911[abstol, reltol]
4912+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4913[lb, ub]
4914-Inf, +Inf
4915
4916break = integrand%break
4917break
4918-10.0000000000000000000000000000000000, -9.00000000000000000000000000000000000, +0.333333333333333333333333333333333317, +0.707106781186547524400844362104849088, +1.00000000000000000000000000000000000
4919call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4920err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4921if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4922getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
492353.7407483834714449977291997202299809, 53.7407483834714449977291997158877577, 0.425730467927014581230905473765272620E-22, 0.434222322303083909134156209630493408E-26 >= 1 (unbiased)? TRUE
4924[numFuncEval, numInterval]
4925+9090, +306
4926
4927
4928!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4929! intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)
4930!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4931
4932!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4933! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
4934!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4935
4936integrand%desc
4937"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
4938[abstol, reltol]
4939+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4940[lb, ub]
4941-Inf, +Inf
4942
4943call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4944err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4945if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4946getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
49471.00000000000000000000000000000000000, 1.00000000000000000000000000000116384, 0.310205711553556471035949677482981893E-23, 0.116383946539320662600172747070407158E-29 >= 1 (unbiased)? TRUE
4948[numFuncEval, numInterval]
4949+355, +3
4950
4951integrand%desc
4952"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
4953[abstol, reltol]
4954+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4955[lb, ub]
4956-Inf, +Inf
4957
4958call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4959err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4960if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4961getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
49621.00000000000000000000000000000000000, 1.00000000000000000000000000000116384, 0.310205711553556471035949677482981893E-23, 0.116383946539320662600172747070407158E-29 >= 1 (unbiased)? TRUE
4963[numFuncEval, numInterval]
4964+355, +3
4965
4966!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4967! Using predefined Gauss-Kronrod 30-61 nodes and weights.
4968!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4969
4970integrand%desc
4971"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
4972[abstol, reltol]
4973+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4974[lb, ub]
4975-Inf, +Inf
4976
4977call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4978err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4979if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4980getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
49811.00000000000000000000000000000000000, 0.999999999999999999999999999999999904, 0.133211282272630652593429624326869237E-31, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
4982[numFuncEval, numInterval]
4983+427, +4
4984
4985integrand%desc
4986"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
4987[abstol, reltol]
4988+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
4989[lb, ub]
4990-Inf, +Inf
4991
4992call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
4993err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
4994if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
4995getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
49961.00000000000000000000000000000000000, 0.999999999999999999999999999999999904, 0.133211282272630652593429624326869237E-31, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
4997[numFuncEval, numInterval]
4998+427, +4
4999
5000!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5001! Using predefined Gauss-Kronrod 25-51 nodes and weights.
5002!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5003
5004integrand%desc
5005"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5006[abstol, reltol]
5007+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5008[lb, ub]
5009-Inf, +Inf
5010
5011call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5012err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5013if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5014getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
50151.00000000000000000000000000000000000, 1.00000000000000000000000000000000000, 0.488468903511507058502358045248036562E-29, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
5016[numFuncEval, numInterval]
5017+357, +4
5018
5019integrand%desc
5020"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5021[abstol, reltol]
5022+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5023[lb, ub]
5024-Inf, +Inf
5025
5026call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5027err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5028if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5029getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
50301.00000000000000000000000000000000000, 1.00000000000000000000000000000000000, 0.488468903511507058502358045248036562E-29, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
5031[numFuncEval, numInterval]
5032+357, +4
5033
5034!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5035! Using predefined Gauss-Kronrod 20-41 nodes and weights.
5036!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5037
5038integrand%desc
5039"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5040[abstol, reltol]
5041+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5042[lb, ub]
5043-Inf, +Inf
5044
5045call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5046err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5047if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5048getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
50491.00000000000000000000000000000000000, 0.999999999999999999999999999999969378, 0.491341375192078885385626303802163761E-23, 0.306222861157570500635900492871003444E-31 >= 1 (unbiased)? TRUE
5050[numFuncEval, numInterval]
5051+287, +4
5052
5053integrand%desc
5054"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5055[abstol, reltol]
5056+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5057[lb, ub]
5058-Inf, +Inf
5059
5060call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5061err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5062if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5063getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
50641.00000000000000000000000000000000000, 0.999999999999999999999999999999969378, 0.491341375192078885385626303802163761E-23, 0.306222861157570500635900492871003444E-31 >= 1 (unbiased)? TRUE
5065[numFuncEval, numInterval]
5066+287, +4
5067
5068!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5069! Using predefined Gauss-Kronrod 15-31 nodes and weights.
5070!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5071
5072integrand%desc
5073"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5074[abstol, reltol]
5075+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5076[lb, ub]
5077-Inf, +Inf
5078
5079call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5080err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5081if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5082getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
50831.00000000000000000000000000000000000, 0.999999999999999999999999999999987481, 0.912680598352143472472829856065255250E-23, 0.125185446385170330448638566268020276E-31 >= 1 (unbiased)? TRUE
5084[numFuncEval, numInterval]
5085+341, +6
5086
5087integrand%desc
5088"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5089[abstol, reltol]
5090+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5091[lb, ub]
5092-Inf, +Inf
5093
5094call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5095err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5096if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5097getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
50981.00000000000000000000000000000000000, 0.999999999999999999999999999999987481, 0.912680598352143472472829856065255250E-23, 0.125185446385170330448638566268020276E-31 >= 1 (unbiased)? TRUE
5099[numFuncEval, numInterval]
5100+341, +6
5101
5102!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5103! Using predefined Gauss-Kronrod 10-21 nodes and weights.
5104!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5105
5106integrand%desc
5107"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5108[abstol, reltol]
5109+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5110[lb, ub]
5111-Inf, +Inf
5112
5113call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5114err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5115if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5116getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
51171.00000000000000000000000000000000000, 0.999999999999999999999999999999999133, 0.386431949672064481044988439592369946E-24, 0.866668474974256133875190074163217293E-33 >= 1 (unbiased)? TRUE
5118[numFuncEval, numInterval]
5119+483, +12
5120
5121integrand%desc
5122"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5123[abstol, reltol]
5124+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5125[lb, ub]
5126-Inf, +Inf
5127
5128call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5129err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5130if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5131getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
51321.00000000000000000000000000000000000, 0.999999999999999999999999999999999133, 0.386431949672064466119465327815932357E-24, 0.866668474974256133875190074163217293E-33 >= 1 (unbiased)? TRUE
5133[numFuncEval, numInterval]
5134+483, +12
5135
5136!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5137! Using predefined Gauss-Kronrod 7-15 nodes and weights.
5138!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5139
5140integrand%desc
5141"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5142[abstol, reltol]
5143+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5144[lb, ub]
5145-Inf, +Inf
5146
5147call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5148err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5149if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5150getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
51511.00000000000000000000000000000000000, 1.00000000000000000000000000000008724, 0.503602725543159631708382701967485206E-22, 0.872446264807417841434358007990972075E-31 >= 1 (unbiased)? TRUE
5152[numFuncEval, numInterval]
5153+705, +24
5154
5155integrand%desc
5156"intNormPDF_type: f(x) = exp(-0.5 * (log(x) - mu)**2 / sigma**2) / (sigma * sqrt(2 * acos(-1.))) for x in (lb, ub)"
5157[abstol, reltol]
5158+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5159[lb, ub]
5160-Inf, +Inf
5161
5162call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5163err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5164if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5165getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
51661.00000000000000000000000000000000000, 1.00000000000000000000000000000008724, 0.503602725543159692264942259244548267E-22, 0.872446264807417841434358007990972075E-31 >= 1 (unbiased)? TRUE
5167[numFuncEval, numInterval]
5168+705, +24
5169
5170
5171!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5172! intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)
5173!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5174
5175!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5176! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
5177!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5178
5179integrand%desc
5180"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5181[abstol, reltol]
5182+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5183[lb, ub]
5184-Inf, +Inf
5185
5186call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5187err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5188if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5189
5190 **** INTEGRATION FAILED: ERR = 3 ****
5191
5192getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
51935.00000000000000000000000000000000000, 4.99999999999999999999983053073095356, 0.148829537543234621901852365616834232E-19, 0.169469269046435394069508017176203785E-21 >= 1 (unbiased)? TRUE
5194[numFuncEval, numInterval]
5195+55735, +393
5196
5197integrand%desc
5198"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5199[abstol, reltol]
5200+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5201[lb, ub]
5202-Inf, +Inf
5203
5204call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5205err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5206if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5207getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
52085.00000000000000000000000000000000000, 5.00000000000000000000000005719560882, 0.220586185914492721267433489481154269E-22, 0.571956088203711499293946877944308075E-25 >= 1 (unbiased)? TRUE
5209[numFuncEval, numInterval]
5210+18531, +131
5211
5212integrand%desc
5213"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5214[abstol, reltol]
5215+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5216[lb, ub]
5217-Inf, +Inf
5218
5219break = integrand%break
5220break
5221-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5222call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5223err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, nodeK, weightK, weightG, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5224if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5225getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
52265.00000000000000000000000000000000000, 5.00000000000000000000000000001013964, 0.788055509822032240309071180535670763E-24, 0.101396359712099193191691126721211253E-28 >= 1 (unbiased)? TRUE
5227[numFuncEval, numInterval]
5228+9514, +70
5229
5230!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5231! Using predefined Gauss-Kronrod 30-61 nodes and weights.
5232!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5233
5234integrand%desc
5235"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5236[abstol, reltol]
5237+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5238[lb, ub]
5239-Inf, +Inf
5240
5241call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5242err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5243if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5244
5245 **** INTEGRATION FAILED: ERR = 3 ****
5246
5247getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
52485.00000000000000000000000000000000000, 4.99999999999999999999969281815568880, 0.148181859417151060456208838788826726E-19, 0.307181844311204184751066583033908737E-21 >= 1 (unbiased)? TRUE
5249[numFuncEval, numInterval]
5250+47885, +393
5251
5252integrand%desc
5253"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5254[abstol, reltol]
5255+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5256[lb, ub]
5257-Inf, +Inf
5258
5259call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5260err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5261if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5262getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
52635.00000000000000000000000000000000000, 4.99999999999999999999999998291505774, 0.269336154506894640885641401876305503E-21, 0.170849422552146576150294284436679620E-25 >= 1 (unbiased)? TRUE
5264[numFuncEval, numInterval]
5265+15921, +131
5266
5267integrand%desc
5268"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5269[abstol, reltol]
5270+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5271[lb, ub]
5272-Inf, +Inf
5273
5274break = integrand%break
5275break
5276-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5277call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5278err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK61, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5279if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5280getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
52815.00000000000000000000000000000000000, 5.00000000000000000000000000000189589, 0.449332958643345025653035995344179889E-23, 0.189588543725479497374830468668060245E-29 >= 1 (unbiased)? TRUE
5282[numFuncEval, numInterval]
5283+8174, +70
5284
5285!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5286! Using predefined Gauss-Kronrod 25-51 nodes and weights.
5287!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5288
5289integrand%desc
5290"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5291[abstol, reltol]
5292+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5293[lb, ub]
5294-Inf, +Inf
5295
5296call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5297err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5298if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5299
5300 **** INTEGRATION FAILED: ERR = 3 ****
5301
5302getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
53035.00000000000000000000000000000000000, 4.99999999999999999999954094074523609, 0.779464639364177429526222142882421036E-20, 0.459059254763912119028468678481861598E-21 >= 1 (unbiased)? TRUE
5304[numFuncEval, numInterval]
5305+40443, +397
5306
5307integrand%desc
5308"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5309[abstol, reltol]
5310+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5311[lb, ub]
5312-Inf, +Inf
5313
5314call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5315err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5316if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5317getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
53185.00000000000000000000000000000000000, 4.99999999999999999999999910472257603, 0.659370729678597724799727277994838557E-22, 0.895277423970657900018874711782395259E-24 >= 1 (unbiased)? TRUE
5319[numFuncEval, numInterval]
5320+13311, +131
5321
5322integrand%desc
5323"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5324[abstol, reltol]
5325+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5326[lb, ub]
5327-Inf, +Inf
5328
5329break = integrand%break
5330break
5331-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5332call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5333err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK51, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5334if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5335getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
53365.00000000000000000000000000000000000, 5.00000000000000000000000000019333640, 0.344985321048354496619167810458626917E-22, 0.193336403397257058344877401744330514E-27 >= 1 (unbiased)? TRUE
5337[numFuncEval, numInterval]
5338+6834, +70
5339
5340!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5341! Using predefined Gauss-Kronrod 20-41 nodes and weights.
5342!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5343
5344integrand%desc
5345"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5346[abstol, reltol]
5347+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5348[lb, ub]
5349-Inf, +Inf
5350
5351call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5352err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5353if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5354
5355 **** INTEGRATION FAILED: ERR = 3 ****
5356
5357getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
53585.00000000000000000000000000000000000, 4.99999999999999999999977508521541938, 0.889511282275936707662601256374826723E-20, 0.224914784580621788312493015510933010E-21 >= 1 (unbiased)? TRUE
5359[numFuncEval, numInterval]
5360+32595, +398
5361
5362integrand%desc
5363"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5364[abstol, reltol]
5365+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5366[lb, ub]
5367-Inf, +Inf
5368
5369call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5370err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5371if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5372getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
53735.00000000000000000000000000000000000, 4.99999999999999999999999995994496739, 0.137823477999278945715823054467102939E-21, 0.400550326120389671097252019271309832E-25 >= 1 (unbiased)? TRUE
5374[numFuncEval, numInterval]
5375+11111, +136
5376
5377integrand%desc
5378"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5379[abstol, reltol]
5380+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5381[lb, ub]
5382-Inf, +Inf
5383
5384break = integrand%break
5385break
5386-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5387call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5388err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK41, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5389if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5390getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
53915.00000000000000000000000000000000000, 4.99999999999999999999999999999746394, 0.795751392913600274283119573409522977E-23, 0.253606455076911217130411175479583229E-29 >= 1 (unbiased)? TRUE
5392[numFuncEval, numInterval]
5393+5986, +76
5394
5395!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5396! Using predefined Gauss-Kronrod 15-31 nodes and weights.
5397!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5398
5399integrand%desc
5400"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5401[abstol, reltol]
5402+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5403[lb, ub]
5404-Inf, +Inf
5405
5406call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5407err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5408if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5409
5410 **** INTEGRATION FAILED: ERR = 3 ****
5411
5412getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
54135.00000000000000000000000000000000000, 5.00000000000000000000060512232370447, 0.176488864050125252523228095113894913E-19, 0.605122323704467180647912884282140312E-21 >= 1 (unbiased)? TRUE
5414[numFuncEval, numInterval]
5415+25699, +415
5416
5417integrand%desc
5418"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5419[abstol, reltol]
5420+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5421[lb, ub]
5422-Inf, +Inf
5423
5424call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5425err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5426if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5427getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
54285.00000000000000000000000000000000000, 4.99999999999999999999999959859587909, 0.242249371133787039593704332999561004E-21, 0.401404120909243665191791041966513634E-24 >= 1 (unbiased)? TRUE
5429[numFuncEval, numInterval]
5430+10199, +165
5431
5432integrand%desc
5433"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5434[abstol, reltol]
5435+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5436[lb, ub]
5437-Inf, +Inf
5438
5439break = integrand%break
5440break
5441-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5442call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5443err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK31, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5444if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5445getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
54465.00000000000000000000000000000000000, 4.99999999999999999999999999999689078, 0.191650111503216410543129537708621019E-21, 0.310922130221875356117357079050910666E-29 >= 1 (unbiased)? TRUE
5447[numFuncEval, numInterval]
5448+4588, +77
5449
5450!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5451! Using predefined Gauss-Kronrod 10-21 nodes and weights.
5452!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5453
5454integrand%desc
5455"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5456[abstol, reltol]
5457+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5458[lb, ub]
5459-Inf, +Inf
5460
5461call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5462err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5463if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5464
5465 **** INTEGRATION FAILED: ERR = 3 ****
5466
5467getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
54685.00000000000000000000000000000000000, 4.99999999999999999999972410297847334, 0.200738257888944093088270474559436884E-19, 0.275897021526661457740995046287992818E-21 >= 1 (unbiased)? TRUE
5469[numFuncEval, numInterval]
5470+21945, +523
5471
5472integrand%desc
5473"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5474[abstol, reltol]
5475+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5476[lb, ub]
5477-Inf, +Inf
5478
5479call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5480err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5481if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5482getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
54835.00000000000000000000000000000000000, 4.99999999999999999999999459739551026, 0.120968281637356032081570111145914346E-21, 0.540260448974324376983886400809375715E-23 >= 1 (unbiased)? TRUE
5484[numFuncEval, numInterval]
5485+10857, +259
5486
5487integrand%desc
5488"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5489[abstol, reltol]
5490+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5491[lb, ub]
5492-Inf, +Inf
5493
5494break = integrand%break
5495break
5496-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5497call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5498err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK21, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5499if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5500getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
55015.00000000000000000000000000000000000, 5.00000000000000000000000000001726789, 0.454085367689341501754388139227418091E-22, 0.172678878813759566584998982332164583E-28 >= 1 (unbiased)? TRUE
5502[numFuncEval, numInterval]
5503+5292, +129
5504
5505!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5506! Using predefined Gauss-Kronrod 7-15 nodes and weights.
5507!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5508
5509integrand%desc
5510"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5511[abstol, reltol]
5512+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5513[lb, ub]
5514-Inf, +Inf
5515
5516call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5517err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5518if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5519
5520 **** INTEGRATION FAILED: ERR = 3 ****
5521
5522getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
55235.00000000000000000000000000000000000, 4.99999999999999999999964016717577831, 0.650624216878426075936931761260022093E-19, 0.359832824221690805328388673584252356E-21 >= 1 (unbiased)? TRUE
5524[numFuncEval, numInterval]
5525+22605, +754
5526
5527integrand%desc
5528"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5529[abstol, reltol]
5530+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5531[lb, ub]
5532-Inf, +Inf
5533
5534call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5535err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5536if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5537getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
55385.00000000000000000000000000000000000, 4.99999999999999999999999989381484476, 0.503284846987234673016163585782518434E-22, 0.106185155244682900454329849424583948E-24 >= 1 (unbiased)? TRUE
5539[numFuncEval, numInterval]
5540+15135, +505
5541
5542integrand%desc
5543"intPentaGammaInf_type: f(x) = sum of five Gamma PDFs with five break points in the integration range x in (-Inf, +Inf)"
5544[abstol, reltol]
5545+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5546[lb, ub]
5547-Inf, +Inf
5548
5549break = integrand%break
5550break
5551-9.00000000000000000000000000000000000, -5.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.00000000000000000000000000000000000
5552call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5553err = getQuadErr(getFunc, ninf, pinf, abstol, reltol, GK15, break, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5554if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5555getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
55565.00000000000000000000000000000000000, 4.99999999999999999999999999999553184, 0.384142579544813447791597719097411376E-22, 0.446815747097838717908986882679703138E-29 >= 1 (unbiased)? TRUE
5557[numFuncEval, numInterval]
5558+7620, +257
5559
5560
5561!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5562! Compute the Cauchy Principal Value over a finite interval.
5563!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5564
5565
5566!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5567! intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)
5568!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5569
5570!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5571! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
5572!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5573
5574integrand%desc
5575"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5576[abstol, reltol]
5577+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5578[lb, ub]
5579-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5580
5581call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5582err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5583if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5584
5585 **** INTEGRATION FAILED: ERR = 3 ****
5586
5587getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5588-0.405465108108164381978013115464349228, -0.915103128150152844213608821604601115, 10.0291797834683825145479356603827519, 0.509638020041988462235595706140251886 >= 1 (unbiased)? TRUE
5589[numFuncEval, numInterval]
5590+14555, +103
5591
5592integrand%desc
5593"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5594[abstol, reltol]
5595+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5596[lb, ub]
5597-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5598
5599call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5600err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5601if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5602
5603 **** INTEGRATION FAILED: ERR = 5 ****
5604
5605getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5606-0.405465108108164381978013115464349228, -0.405465108108164381978013115464324817, 0.501704750512874939721082254043373566E-31, 0.244111620451082144374845204222639538E-31 >= 1 (unbiased)? TRUE
5607[numFuncEval, numInterval]
5608+1207, +9
5609
5610integrand%desc
5611"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5612[abstol, reltol]
5613+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5614[lb, ub]
5615-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5616
5617integrand%wcauchy%cs
5618+1.00000000000000000000000000000000000
5619call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5620err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, nodeK, weightK, weightG, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5621if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5622getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5623-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5624[numFuncEval, numInterval]
5625+25, +1
5626
5627!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5628! Using predefined Gauss-Kronrod 30-61 nodes and weights.
5629!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5630
5631integrand%desc
5632"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5633[abstol, reltol]
5634+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5635[lb, ub]
5636-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5637
5638call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5639err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5640if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5641
5642 **** INTEGRATION FAILED: ERR = 3 ****
5643
5644getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5645-0.405465108108164381978013115464349228, -11.3331967748993037045211308642082481, 23.2445101247878124858385910225044426, 10.9277316667911393225431177487438991 >= 1 (unbiased)? TRUE
5646[numFuncEval, numInterval]
5647+12505, +103
5648
5649integrand%desc
5650"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5651[abstol, reltol]
5652+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5653[lb, ub]
5654-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5655
5656call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5657err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5658if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5659
5660 **** INTEGRATION FAILED: ERR = 5 ****
5661
5662getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5663-0.405465108108164381978013115464349228, -0.405465108108164381978013115464181143, 0.353456293043667459932098351912898786E-30, 0.168085535896396009075460474939099532E-30 >= 1 (unbiased)? TRUE
5664[numFuncEval, numInterval]
5665+1159, +10
5666
5667integrand%desc
5668"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5669[abstol, reltol]
5670+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5671[lb, ub]
5672-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5673
5674integrand%wcauchy%cs
5675+1.00000000000000000000000000000000000
5676call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5677err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK61, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5678if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5679getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5680-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5681[numFuncEval, numInterval]
5682+25, +1
5683
5684!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5685! Using predefined Gauss-Kronrod 25-51 nodes and weights.
5686!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5687
5688integrand%desc
5689"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5690[abstol, reltol]
5691+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5692[lb, ub]
5693-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5694
5695call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5696err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5697if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5698
5699 **** INTEGRATION FAILED: ERR = 3 ****
5700
5701getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5702-0.405465108108164381978013115464349228, -0.905104586408265809617746382766692903, 8.58793063064077668118896821403563513, 0.499639478300101427639733267302343675 >= 1 (unbiased)? TRUE
5703[numFuncEval, numInterval]
5704+10557, +104
5705
5706integrand%desc
5707"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5708[abstol, reltol]
5709+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5710[lb, ub]
5711-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5712
5713call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5714err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5715if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5716
5717 **** INTEGRATION FAILED: ERR = 5 ****
5718
5719getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5720-0.405465108108164381978013115464349228, -0.405465108108164381978013115464389095, 0.929261198166841299099509357297227431E-32, 0.398667498488157821582587434115079955E-31 >= 1 (unbiased)? FALSE
5721[numFuncEval, numInterval]
5722+969, +10
5723
5724integrand%desc
5725"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5726[abstol, reltol]
5727+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5728[lb, ub]
5729-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5730
5731integrand%wcauchy%cs
5732+1.00000000000000000000000000000000000
5733call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5734err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK51, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5735if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5736getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5737-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5738[numFuncEval, numInterval]
5739+25, +1
5740
5741!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5742! Using predefined Gauss-Kronrod 20-41 nodes and weights.
5743!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5744
5745integrand%desc
5746"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5747[abstol, reltol]
5748+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5749[lb, ub]
5750-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5751
5752call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5753err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5754if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5755
5756 **** INTEGRATION FAILED: ERR = 3 ****
5757
5758getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5759-0.405465108108164381978013115464349228, -1.39335867553529350606518549676176590, 8.27849259141594481958692370533071838, 0.987893567427129124087172381297416669 >= 1 (unbiased)? TRUE
5760[numFuncEval, numInterval]
5761+8487, +104
5762
5763integrand%desc
5764"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5765[abstol, reltol]
5766+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5767[lb, ub]
5768-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5769
5770call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5771err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5772if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5773
5774 **** INTEGRATION FAILED: ERR = 5 ****
5775
5776getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5777-0.405465108108164381978013115464349228, -0.405465108108164381978013115463734664, 0.185717424537261153310187953003464541E-29, 0.614564245253966960710162561478850307E-30 >= 1 (unbiased)? TRUE
5778[numFuncEval, numInterval]
5779+1107, +14
5780
5781integrand%desc
5782"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5783[abstol, reltol]
5784+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5785[lb, ub]
5786-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5787
5788integrand%wcauchy%cs
5789+1.00000000000000000000000000000000000
5790call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5791err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK41, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5792if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5793getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5794-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5795[numFuncEval, numInterval]
5796+25, +1
5797
5798!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5799! Using predefined Gauss-Kronrod 15-31 nodes and weights.
5800!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5801
5802integrand%desc
5803"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5804[abstol, reltol]
5805+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5806[lb, ub]
5807-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5808
5809call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5810err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5811if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5812
5813 **** INTEGRATION FAILED: ERR = 3 ****
5814
5815getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5816-0.405465108108164381978013115464349228, -1.96385094958119378032688209834218890, 8.11352095731798158366750002316285264, 1.55838584147302939834886898287783968 >= 1 (unbiased)? TRUE
5817[numFuncEval, numInterval]
5818+6417, +104
5819
5820integrand%desc
5821"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5822[abstol, reltol]
5823+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5824[lb, ub]
5825-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5826
5827call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5828err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5829if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5830
5831 **** INTEGRATION FAILED: ERR = 5 ****
5832
5833getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5834-0.405465108108164381978013115464349228, -0.405465108108164381978013115464260732, 0.635792808065975267900472078350992669E-29, 0.884964809445934874479221864617774103E-31 >= 1 (unbiased)? TRUE
5835[numFuncEval, numInterval]
5836+1085, +18
5837
5838integrand%desc
5839"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5840[abstol, reltol]
5841+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5842[lb, ub]
5843-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5844
5845integrand%wcauchy%cs
5846+1.00000000000000000000000000000000000
5847call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5848err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK31, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5849if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5850getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5851-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5852[numFuncEval, numInterval]
5853+25, +1
5854
5855!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5856! Using predefined Gauss-Kronrod 10-21 nodes and weights.
5857!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5858
5859integrand%desc
5860"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5861[abstol, reltol]
5862+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5863[lb, ub]
5864-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5865
5866call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5867err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5868if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5869
5870 **** INTEGRATION FAILED: ERR = 3 ****
5871
5872getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5873-0.405465108108164381978013115464349228, -2.04356971055286136189443548589605091, 7.24146052036062818462419495305868050, 1.63810460244469697991642237043170168 >= 1 (unbiased)? TRUE
5874[numFuncEval, numInterval]
5875+4389, +105
5876
5877integrand%desc
5878"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5879[abstol, reltol]
5880+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5881[lb, ub]
5882-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5883
5884call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5885err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5886if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5887
5888 **** INTEGRATION FAILED: ERR = 5 ****
5889
5890getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5891-0.405465108108164381978013115464349228, -0.405465108108164381978013115464718525, 0.948013123403926992764805620933964846E-25, 0.369297066836252474823483770490659813E-30 >= 1 (unbiased)? TRUE
5892[numFuncEval, numInterval]
5893+1155, +28
5894
5895integrand%desc
5896"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5897[abstol, reltol]
5898+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5899[lb, ub]
5900-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5901
5902integrand%wcauchy%cs
5903+1.00000000000000000000000000000000000
5904call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5905err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK21, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5906if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5907getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5908-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5909[numFuncEval, numInterval]
5910+25, +1
5911
5912!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5913! Using predefined Gauss-Kronrod 7-15 nodes and weights.
5914!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5915
5916integrand%desc
5917"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5918[abstol, reltol]
5919+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5920[lb, ub]
5921-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5922
5923call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5924err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5925if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5926
5927 **** INTEGRATION FAILED: ERR = 3 ****
5928
5929getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5930-0.405465108108164381978013115464349228, 25.6581525657940527271541507997975738, 43.7725212703328144915777368136988984, 26.0636176739022171091321639152619244 >= 1 (unbiased)? TRUE
5931[numFuncEval, numInterval]
5932+3135, +105
5933
5934integrand%desc
5935"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5936[abstol, reltol]
5937+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5938[lb, ub]
5939-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5940
5941call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5942err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5943if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5944
5945 **** INTEGRATION FAILED: ERR = 5 ****
5946
5947getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5948-0.405465108108164381978013115464349228, -0.405465108108164381978013115463569275, 0.400579094949304848203147703839104326E-23, 0.779953479228220839591344667298330941E-30 >= 1 (unbiased)? TRUE
5949[numFuncEval, numInterval]
5950+1875, +63
5951
5952integrand%desc
5953"intCauchy1_type: an integrand of the form w(x) * f(x) with Cauchy weight w(x) 1 / (x - cs) and f(x) = 1 ~,~ x \in (lb < cs, cs < ub)"
5954[abstol, reltol]
5955+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5956[lb, ub]
5957-2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000
5958
5959integrand%wcauchy%cs
5960+1.00000000000000000000000000000000000
5961call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5962err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK15, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5963if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5964getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5965-0.405465108108164381978013115464349228, -0.405465108108164381978013115464349036, 0.192592994438723585305597794258492732E-33, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
5966[numFuncEval, numInterval]
5967+25, +1
5968
5969
5970!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5971! intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)
5972!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5973
5974!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5975! Using arbitrary Gauss-Kronrod nodes and weights (here: 35-71).
5976!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5977
5978integrand%desc
5979"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
5980[abstol, reltol]
5981+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
5982[lb, ub]
5983-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
5984
5985call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
5986err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
5987if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
5988
5989 **** INTEGRATION FAILED: ERR = 3 ****
5990
5991getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
5992-0.635610766069589123929388320259411106, -0.535594005918940481480596099467779229, 1.99766883996688893323382397463559461, 0.100016760150648642448792220791631876 >= 1 (unbiased)? TRUE
5993[numFuncEval, numInterval]
5994+14413, +102
5995
5996integrand%desc
5997"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
5998[abstol, reltol]
5999+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6000[lb, ub]
6001-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6002
6003call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6004err = getQuadErr(getFunc, lb, ub, abstol, reltol, nodeK, weightK, weightG, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6005if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6006
6007 **** INTEGRATION FAILED: ERR = 5 ****
6008
6009getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6010-0.635610766069589123929388320259411106, -0.635610766069589123929388320259253372, 0.463186151625130222659962695191675020E-30, 0.157733662445314616365284593497705547E-30 >= 1 (unbiased)? TRUE
6011[numFuncEval, numInterval]
6012+1349, +10
6013
6014integrand%desc
6015"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6016[abstol, reltol]
6017+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6018[lb, ub]
6019-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6020
6021integrand%wcauchy%cs
6022-2.00000000000000000000000000000000000
6023call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6024err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, nodeK, weightK, weightG, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6025if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6026getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6027-0.635610766069589123929388320259411106, -0.635610766069589123929388320259411491, 0.458496862759492376246073374011120524E-24, 0.385185988877447170611195588516985464E-33 >= 1 (unbiased)? TRUE
6028[numFuncEval, numInterval]
6029+793, +9
6030
6031!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6032! Using predefined Gauss-Kronrod 30-61 nodes and weights.
6033!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6034
6035integrand%desc
6036"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6037[abstol, reltol]
6038+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6039[lb, ub]
6040-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6041
6042call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6043err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6044if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6045
6046 **** INTEGRATION FAILED: ERR = 3 ****
6047
6048getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6049-0.635610766069589123929388320259411106, 1.45660265693814143156056752760615743, 4.48301682864900517932815977426235523, 2.09221342300773055548995584786556854 >= 1 (unbiased)? TRUE
6050[numFuncEval, numInterval]
6051+12383, +102
6052
6053integrand%desc
6054"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6055[abstol, reltol]
6056+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6057[lb, ub]
6058-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6059
6060call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6061err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK61, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6062if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6063
6064 **** INTEGRATION FAILED: ERR = 5 ****
6065
6066getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6067-0.635610766069589123929388320259411106, -0.635610766069589123929388320259525506, 0.308148791101957736488956470813588371E-32, 0.114400238696601809671525089789544683E-30 >= 1 (unbiased)? FALSE
6068[numFuncEval, numInterval]
6069+1159, +10
6070
6071integrand%desc
6072"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6073[abstol, reltol]
6074+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6075[lb, ub]
6076-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6077
6078integrand%wcauchy%cs
6079-2.00000000000000000000000000000000000
6080call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6081err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK61, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6082if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6083getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6084-0.635610766069589123929388320259411106, -0.635610766069589123929388320259411298, 0.458496862759492376246073374011120524E-24, 0.192592994438723585305597794258492732E-33 >= 1 (unbiased)? TRUE
6085[numFuncEval, numInterval]
6086+713, +9
6087
6088!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6089! Using predefined Gauss-Kronrod 25-51 nodes and weights.
6090!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6091
6092integrand%desc
6093"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6094[abstol, reltol]
6095+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6096[lb, ub]
6097-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6098
6099call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6100err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6101if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6102
6103 **** INTEGRATION FAILED: ERR = 3 ****
6104
6105getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6106-0.635610766069589123929388320259411106, -0.538004443349170675733846293911143070, 1.70499824732515084419974546900198492, 0.976063227204184481955420263482680359E-1 >= 1 (unbiased)? TRUE
6107[numFuncEval, numInterval]
6108+10455, +103
6109
6110integrand%desc
6111"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6112[abstol, reltol]
6113+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6114[lb, ub]
6115-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6116
6117call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6118err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK51, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6119if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6120
6121 **** INTEGRATION FAILED: ERR = 5 ****
6122
6123getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6124-0.635610766069589123929388320259411106, -0.635610766069589123929388320259521076, 0.181807786750155064528484317780017139E-30, 0.109970599824511167209496340521599350E-30 >= 1 (unbiased)? TRUE
6125[numFuncEval, numInterval]
6126+969, +10
6127
6128integrand%desc
6129"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6130[abstol, reltol]
6131+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6132[lb, ub]
6133-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6134
6135integrand%wcauchy%cs
6136-2.00000000000000000000000000000000000
6137call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6138err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK51, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6139if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6140getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6141-0.635610766069589123929388320259411106, -0.635610766069589123929388320259411202, 0.458496862759492376246073374011120524E-24, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
6142[numFuncEval, numInterval]
6143+633, +9
6144
6145!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6146! Using predefined Gauss-Kronrod 20-41 nodes and weights.
6147!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6148
6149integrand%desc
6150"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6151[abstol, reltol]
6152+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6153[lb, ub]
6154-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6155
6156call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6157err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6158if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6159
6160 **** INTEGRATION FAILED: ERR = 3 ****
6161
6162getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6163-0.635610766069589123929388320259411106, -0.437542143888234679456153575207258786, 1.65490787784125387711254835382410950, 0.198068622181354444473234745052152320 >= 1 (unbiased)? TRUE
6164[numFuncEval, numInterval]
6165+8405, +103
6166
6167integrand%desc
6168"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6169[abstol, reltol]
6170+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6171[lb, ub]
6172-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6173
6174call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6175err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK41, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6176if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6177
6178 **** INTEGRATION FAILED: ERR = 5 ****
6179
6180getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6181-0.635610766069589123929388320259411106, -0.635610766069589123929388320259431135, 0.388074883794028024390779555430862855E-31, 0.200296714216272528717821706028832441E-31 >= 1 (unbiased)? TRUE
6182[numFuncEval, numInterval]
6183+943, +12
6184
6185integrand%desc
6186"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6187[abstol, reltol]
6188+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6189[lb, ub]
6190-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6191
6192integrand%wcauchy%cs
6193-2.00000000000000000000000000000000000
6194call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6195err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK41, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6196if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6197getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6198-0.635610766069589123929388320259411106, -0.635610766069589123929388320259411202, 0.458496994102030499545723739521740202E-24, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
6199[numFuncEval, numInterval]
6200+553, +9
6201
6202!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6203! Using predefined Gauss-Kronrod 15-31 nodes and weights.
6204!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6205
6206integrand%desc
6207"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6208[abstol, reltol]
6209+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6210[lb, ub]
6211-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6212
6213call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6214err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6215if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6216
6217 **** INTEGRATION FAILED: ERR = 3 ****
6218
6219getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6220-0.635610766069589123929388320259411106, -0.321266249478085113548529040091370738, 1.62017896737387654616388863025316796, 0.314344516591504010380859280168040368 >= 1 (unbiased)? TRUE
6221[numFuncEval, numInterval]
6222+6355, +103
6223
6224integrand%desc
6225"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6226[abstol, reltol]
6227+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6228[lb, ub]
6229-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6230
6231call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6232err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK31, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6233if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6234
6235 **** INTEGRATION FAILED: ERR = 5 ****
6236
6237getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6238-0.635610766069589123929388320259411106, -0.635610766069589123929388320176435881, 0.827288985401370322387754493171183284E-28, 0.829752249800241597043813088959749407E-28 >= 1 (unbiased)? FALSE
6239[numFuncEval, numInterval]
6240+1085, +18
6241
6242integrand%desc
6243"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6244[abstol, reltol]
6245+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6246[lb, ub]
6247-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6248
6249integrand%wcauchy%cs
6250-2.00000000000000000000000000000000000
6251call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6252err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK31, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6253if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6254getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6255-0.635610766069589123929388320259411106, -0.635610766069589123929388320259411202, 0.458497375334801230327203475186647068E-24, 0.962964972193617926527988971292463659E-34 >= 1 (unbiased)? TRUE
6256[numFuncEval, numInterval]
6257+535, +10
6258
6259!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6260! Using predefined Gauss-Kronrod 10-21 nodes and weights.
6261!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6262
6263integrand%desc
6264"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6265[abstol, reltol]
6266+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6267[lb, ub]
6268-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6269
6270call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6271err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6272if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6273
6274 **** INTEGRATION FAILED: ERR = 3 ****
6275
6276getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6277-0.635610766069589123929388320259411106, -0.313635651749756707119425316680125425, 1.43562881981449143882504794728653286, 0.321975114319832416809963003579285681 >= 1 (unbiased)? TRUE
6278[numFuncEval, numInterval]
6279+4347, +104
6280
6281integrand%desc
6282"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6283[abstol, reltol]
6284+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6285[lb, ub]
6286-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6287
6288call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6289err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK21, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6290if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6291
6292 **** INTEGRATION FAILED: ERR = 5 ****
6293
6294getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6295-0.635610766069589123929388320259411106, -0.635610766069589123929388320259486024, 0.597574162078157671474307003603174143E-24, 0.749186748366634746838775419665536727E-31 >= 1 (unbiased)? TRUE
6296[numFuncEval, numInterval]
6297+1197, +29
6298
6299integrand%desc
6300"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6301[abstol, reltol]
6302+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6303[lb, ub]
6304-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6305
6306integrand%wcauchy%cs
6307-2.00000000000000000000000000000000000
6308call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6309err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK21, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6310if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6311getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6312-0.635610766069589123929388320259411106, -0.635610766069589123929388320259411106, 0.485640976828224618892203332811773371E-24, 0.00000000000000000000000000000000000 >= 1 (unbiased)? TRUE
6313[numFuncEval, numInterval]
6314+771, +18
6315
6316!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6317! Using predefined Gauss-Kronrod 7-15 nodes and weights.
6318!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6319
6320integrand%desc
6321"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6322[abstol, reltol]
6323+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6324[lb, ub]
6325-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6326
6327call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6328err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6329if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6330
6331 **** INTEGRATION FAILED: ERR = 3 ****
6332
6333getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6334-0.635610766069589123929388320259411106, -5.84924813915432255448624616796316749, 8.75430206830542412204383260468105710, 5.21363737308473343055685784770375657 >= 1 (unbiased)? TRUE
6335[numFuncEval, numInterval]
6336+3105, +104
6337
6338integrand%desc
6339"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6340[abstol, reltol]
6341+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6342[lb, ub]
6343-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6344
6345call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6346err = getQuadErr(getFunc, lb, ub, abstol, reltol, GK15, weps, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6347if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6348
6349 **** INTEGRATION FAILED: ERR = 5 ****
6350
6351getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6352-0.635610766069589123929388320259411106, -0.635610766069589123929388320262825009, 0.160024007118202936108978586388617895E-23, 0.341390341942081427312702650102604216E-29 >= 1 (unbiased)? TRUE
6353[numFuncEval, numInterval]
6354+2025, +68
6355
6356integrand%desc
6357"intCauchy2_type: an integrand of the form w(x) * f(x) = 1 / (x + 2.) / (x - 3.) for x in (-3., 2.)"
6358[abstol, reltol]
6359+0.00000000000000000000000000000000000, +0.559579552072376591733071579965869345E-22
6360[lb, ub]
6361-3.00000000000000000000000000000000000, +2.00000000000000000000000000000000000
6362
6363integrand%wcauchy%cs
6364-2.00000000000000000000000000000000000
6365call setNodeWeightGK(order = 35_IK, nodeK = nodeK, weightK = weightK, weightG = weightG) ! Compute the 35-71 Gauss-Kronrod nodes and weights.
6366err = getQuadErr(getFuncUnweighted, lb, ub, abstol, reltol, GK15, integrand%wcauchy, integral, abserr, sinfo, sindex, numFuncEval, numInterval)
6367if (err /= 0_IK) call disp%show(getStrUpper(SK_' **** integration failed: err = '//getStr(err)//SK_' ****'), tmsize = 1_IK, bmsize = 1_IK)
6368getStr([truth, integral, abserr, abs(integral - truth)])//SK_' >= 1 (unbiased)? '//getStr(abs(integral - truth) <= abserr)
6369-0.635610766069589123929388320259411106, -0.635610766069589123929388320259413128, 0.339257203369347874671069594088676377E-22, 0.202222644160659764570877683971417368E-32 >= 1 (unbiased)? TRUE
6370[numFuncEval, numInterval]
6371+1215, +38
6372
6373
pm_quadPack::setNodeWeightGK
Return the Kronrod nodes and weights of the extension to the -point Gauss-Legendre quadrature,...
Definition: pm_quadPack.F90:2036
pm_quadPack::GK31
type(GK31_type), parameter GK31
The scalar constant object of type GK31_type that indicates the use of 15-point Gauss-Legendre quadra...
Definition: pm_quadPack.F90:1074
pm_quadPack::GK51
type(GK51_type), parameter GK51
The scalar constant object of type GK51_type that indicates the use of 25-point Gauss-Legendre quadra...
Definition: pm_quadPack.F90:1528
pm_quadPack::weps
type(weps_type), parameter weps
The scalar constant object of type weps_type that indicates the use of Epsilon extrapolation method o...
Definition: pm_quadPack.F90:4551
pm_quadPack::GK61
type(GK61_type), parameter GK61
The scalar constant object of type GK61_type that indicates the use of 30-point Gauss-Legendre quadra...
Definition: pm_quadPack.F90:1778
pm_quadPack::GK21
type(GK21_type), parameter GK21
The scalar constant object of type GK21_type that indicates the use of 10-point Gauss-Legendre quadra...
Definition: pm_quadPack.F90:870
pm_quadPack::GK15
type(GK15_type), parameter GK15
The scalar constant object of type GK15_type that indicates the use of 7-point Gauss-Legendre quadrat...
Definition: pm_quadPack.F90:674
pm_quadPack::GK41
type(GK41_type), parameter GK41
The scalar constant object of type GK41_type that indicates the use of 20-point Gauss-Legendre quadra...
Definition: pm_quadPack.F90:1294
Test:
test_pm_quadPack


Final Remarks ⛓

If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

  1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
  2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Copyright
Computational Data Science Lab
Author:
Amir Shahmoradi, Oct 16, 2009, 11:14 AM, Michigan

Definition at line 5643 of file pm_quadPack.F90.

The documentation for this interface was generated from the following file: