[Quantlib-dev] Max date of a PiecewiseYieldCurve term structure

[Aurelien C. <aur...@gm...>]

Hi,

It looks like the max date of a PiecewiseYieldCurve term structure
whose reference date depends on the global evaluation date isn't
properly updated when modifying the global evaluation date.

The reason for this is that the max date (dates_.back()) of such a
curve is set *before* the rate helpers get a chance to know about the
change of evaluation date. The following patch apparently fixes the
issue. This patch doesn't cause any error in the testsuite.

Is there something I'm overlooking ?

Cheers,
Aurelien


    template <class C, class I>
    void PiecewiseYieldCurve<C,I>::performCalculations() const {
        // setup vectors
        Size n =3D instruments_.size();
        for (Size i=3D0 ; i < n ; i++) {
                // don't try this at home!
                instruments_[i]->setTermStructure(
                                 const_cast<PiecewiseYieldCurve<C,I>*>(this=
));
        }
        this->dates_ =3D std::vector<Date>(n+1);
        this->times_ =3D std::vector<Time>(n+1);
        this->data_ =3D std::vector<Real>(n+1);
        this->dates_[0] =3D this->referenceDate();
        this->times_[0] =3D 0.0;
        this->data_[0] =3D C::initialValue();
        for (Size i=3D0; i<n; i++) {
            this->dates_[i+1] =3D instruments_[i]->latestDate();
            this->times_[i+1] =3D this->timeFromReference(this->dates_[i+1]=
);
            this->data_[i+1] =3D this->data_[i];
        }
        Brent solver;
        Size maxIterations =3D 25;
        // bootstrapping loop
        for (Size iteration =3D 0; ; iteration++) {
            std::vector<Real> previousData =3D this->data_;
            Size i;
            for (i=3D1; i<n+1; i++) {
                if (iteration =3D=3D 0) {
                    // extend interpolation a point at a time
                    if (I::global && i < 2) {
                        // not enough points for splines
                        this->interpolation_ =3D Linear().interpolate(
                                                    this->times_.begin(),
                                                    this->times_.begin()+i+=
1,
                                                    this->data_.begin());
                    } else {
                        this->interpolation_ =3D this->interpolator_.interp=
olate(
                                                    this->times_.begin(),
                                                    this->times_.begin()+i+=
1,
                                                    this->data_.begin());
                    }
                }
                boost::shared_ptr<RateHelper> instrument =3D instruments_[i=
-1];
                // don't try this at home!
                // instrument->setTermStructure(
                //                =20
const_cast<PiecewiseYieldCurve<C,I>*>(this));
                Real guess;
                if (iteration > 0) {
                    // use perturbed value from previous loop
                    guess =3D 0.99*this->data_[i];
                } else if (i > 1) {
                    // extrapolate
                    guess =3D C::guess(this,this->dates_[i]);
                } else {
                    guess =3D C::initialGuess();
                }
                // bracket
                Real min =3D C::minValueAfter(i, this->data_);
                Real max =3D C::maxValueAfter(i, this->data_);
                if (guess <=3D min || guess >=3D max)
                    guess =3D (min+max)/2.0;
                this->data_[i] =3D
                    solver.solve(ObjectiveFunction(this,instrument,i),
                                                   accuracy_,guess,min,max)=
;
            }
            // check exit conditions
            if (!I::global)
                break;   // no need for convergence loop

            Real improvement =3D 0.0;
            for (i=3D1; i<n+1; i++)
                improvement +=3D std::abs(this->data_[i]-previousData[i]);
            if (improvement <=3D n*accuracy_)  // convergence reached
                break;

            if (iteration > maxIterations)
                QL_FAIL("convergence not reached after "
                        << maxIterations << " iterations");
        }
    }