コード例 #1
0
Real GaussKronrodAdaptive::integrateRecursively(
    const boost::function<Real (Real)>& f,
    Real a,
    Real b,
    Real tolerance) const {

    Real halflength = (b - a) / 2;
    Real center = (a + b) / 2;

    Real g7; // will be result of G7 integral
    Real k15; // will be result of K15 integral

    Real t, fsum; // t (abscissa) and f(t)
    Real fc = f(center);
    g7 = fc * g7w[0];
    k15 = fc * k15w[0];

    // calculate g7 and half of k15
    Integer j, j2;
    for (j = 1, j2 = 2; j < 4; j++, j2 += 2) {
        t = halflength * k15t[j2];
        fsum = f(center - t) + f(center + t);
        g7  += fsum * g7w[j];
        k15 += fsum * k15w[j2];
    }

    // calculate other half of k15
    for (j2 = 1; j2 < 8; j2 += 2) {
        t = halflength * k15t[j2];
        fsum = f(center - t) + f(center + t);
        k15 += fsum * k15w[j2];
    }

    // multiply by (a - b) / 2
    g7 = halflength * g7;
    k15 = halflength * k15;

    // 15 more function evaluations have been used
    increaseNumberOfEvaluations(15);

    // error is <= k15 - g7
    // if error is larger than tolerance then split the interval
    // in two and integrate recursively
    if (std::fabs(k15 - g7) < tolerance) {
        return k15;
    } else {
        QL_REQUIRE(numberOfEvaluations()+30 <=
                   maxEvaluations(),
                   "maximum number of function evaluations "
                   "exceeded");
        return integrateRecursively(f, a, center, tolerance/2)
               + integrateRecursively(f, center, b, tolerance/2);
    }
}
コード例 #2
0
 Real GaussLobattoIntegral::adaptivGaussLobattoStep(
                                  const boost::function<Real (Real)>& f,
                                  Real a, Real b, Real fa, Real fb,
                                  Real acc) const {
     QL_REQUIRE(numberOfEvaluations() < maxEvaluations(),
                "max number of iterations reached");
     
     const Real h=(b-a)/2; 
     const Real m=(a+b)/2;
     
     const Real mll=m-alpha_*h; 
     const Real ml =m-beta_*h; 
     const Real mr =m+beta_*h; 
     const Real mrr=m+alpha_*h;
     
     const Real fmll= f(mll);
     const Real fml = f(ml);
     const Real fm  = f(m);
     const Real fmr = f(mr);
     const Real fmrr= f(mrr);
     increaseNumberOfEvaluations(5);
     
     const Real integral2=(h/6)*(fa+fb+5*(fml+fmr));
     const Real integral1=(h/1470)*(77*(fa+fb)
                                    +432*(fmll+fmrr)+625*(fml+fmr)+672*fm);
     
     // avoid 80 bit logic on x86 cpu
     volatile Real dist = acc + (integral1-integral2);
     if(dist==acc || mll<=a || b<=mrr) {
         QL_REQUIRE(m>a && b>m,"Interval contains no more machine number");
         return integral1;
     }
     else {
         return  adaptivGaussLobattoStep(f,a,mll,fa,fmll,acc)  
               + adaptivGaussLobattoStep(f,mll,ml,fmll,fml,acc)
               + adaptivGaussLobattoStep(f,ml,m,fml,fm,acc)
               + adaptivGaussLobattoStep(f,m,mr,fm,fmr,acc)
               + adaptivGaussLobattoStep(f,mr,mrr,fmr,fmrr,acc)
               + adaptivGaussLobattoStep(f,mrr,b,fmrr,fb,acc);
     }
 }