Real GaussLobattoIntegral::integrate(
const boost::function<Real (Real)>& f,
Real a, Real b) const {
setNumberOfEvaluations(0);
const Real calcAbsTolerance = calculateAbsTolerance(f, a, b);
increaseNumberOfEvaluations(2);
return adaptivGaussLobattoStep(f, a, b, f(a), f(b), calcAbsTolerance);
}
Real
GaussKronrodNonAdaptive::integrate(const boost::function<Real (Real)>& f,
Real a,
Real b) const {
Real result;
//Size neval;
Real fv1[5], fv2[5], fv3[5], fv4[5];
Real savfun[21]; /* array of function values which have been computed */
Real res10, res21, res43, res87; /* 10, 21, 43 and 87 point results */
Real err;
Real resAbs; /* approximation to the integral of abs(f) */
Real resasc; /* approximation to the integral of abs(f-i/(b-a)) */
int k ;
QL_REQUIRE(a<b, "b must be greater than a)");
const Real halfLength = 0.5 * (b - a);
const Real center = 0.5 * (b + a);
const Real fCenter = f(center);
// Compute the integral using the 10- and 21-point formula.
res10 = 0;
res21 = w21b[5] * fCenter;
resAbs = w21b[5] * std::fabs(fCenter);
for (k = 0; k < 5; k++) {
Real abscissa = halfLength * x1[k];
Real fval1 = f(center + abscissa);
Real fval2 = f(center - abscissa);
Real fval = fval1 + fval2;
res10 += w10[k] * fval;
res21 += w21a[k] * fval;
resAbs += w21a[k] * (std::fabs(fval1) + std::fabs(fval2));
savfun[k] = fval;
fv1[k] = fval1;
fv2[k] = fval2;
}
for (k = 0; k < 5; k++) {
Real abscissa = halfLength * x2[k];
Real fval1 = f(center + abscissa);
Real fval2 = f(center - abscissa);
Real fval = fval1 + fval2;
res21 += w21b[k] * fval;
resAbs += w21b[k] * (std::fabs(fval1) + std::fabs(fval2));
savfun[k + 5] = fval;
fv3[k] = fval1;
fv4[k] = fval2;
}
result = res21 * halfLength;
resAbs *= halfLength ;
Real mean = 0.5 * res21;
resasc = w21b[5] * std::fabs(fCenter - mean);
for (k = 0; k < 5; k++)
resasc += (w21a[k] * (std::fabs(fv1[k] - mean)
+ std::fabs(fv2[k] - mean))
+ w21b[k] * (std::fabs(fv3[k] - mean)
+ std::fabs(fv4[k] - mean)));
err = rescaleError ((res21 - res10) * halfLength, resAbs, resasc) ;
resasc *= halfLength ;
// test for convergence.
if (err < absoluteAccuracy() || err < relativeAccuracy() * std::fabs(result)) {
setAbsoluteError(err);
setNumberOfEvaluations(21);
return result;
}
/* compute the integral using the 43-point formula. */
res43 = w43b[11] * fCenter;
for (k = 0; k < 10; k++)
res43 += savfun[k] * w43a[k];
for (k = 0; k < 11; k++) {
Real abscissa = halfLength * x3[k];
Real fval = (f(center + abscissa)
+ f(center - abscissa));
res43 += fval * w43b[k];
savfun[k + 10] = fval;
}
// test for convergence.
result = res43 * halfLength;
err = rescaleError ((res43 - res21) * halfLength, resAbs, resasc);
if (err < absoluteAccuracy() || err < relativeAccuracy() * std::fabs(result)) {
setAbsoluteError(err);
setNumberOfEvaluations(43);
return result;
}
/* compute the integral using the 87-point formula. */
res87 = w87b[22] * fCenter;
for (k = 0; k < 21; k++)
res87 += savfun[k] * w87a[k];
for (k = 0; k < 22; k++) {
Real abscissa = halfLength * x4[k];
res87 += w87b[k] * (f(center + abscissa)
+ f(center - abscissa));
}
// test for convergence.
result = res87 * halfLength ;
err = rescaleError ((res87 - res43) * halfLength, resAbs, resasc);
setAbsoluteError(err);
setNumberOfEvaluations(87);
return result;
}
