OvernightIndexedCouponPricer Class Reference

OvernightIndexedCoupon pricer. More...

#include <qle/cashflows/overnightindexedcoupon.hpp>

Inheritance diagram for OvernightIndexedCouponPricer:

Collaboration diagram for OvernightIndexedCouponPricer:

Public Member Functions
void	initialize (const FloatingRateCoupon &coupon) override
void	compute () const
Rate	swapletRate () const override
Rate	effectiveSpread () const
Rate	effectiveIndexFixing () const
Real	swapletPrice () const override
Real	capletPrice (Rate) const override
Rate	capletRate (Rate) const override
Real	floorletPrice (Rate) const override
Rate	floorletRate (Rate) const override

Protected Attributes
const OvernightIndexedCoupon *	coupon_
Real	swapletRate_
Real	effectiveSpread_
Real	effectiveIndexFixing_

Detailed Description

OvernightIndexedCoupon pricer.

Definition at line 133 of file overnightindexedcoupon.hpp.

Member Function Documentation

initialize()

void initialize ( const FloatingRateCoupon &  coupon )

override

Definition at line 190 of file overnightindexedcoupon.cpp.

                                                                              {
    coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
    QL_ENSURE(coupon_, "wrong coupon type");
}

compute()

void compute

(

)

const

Definition at line 195 of file overnightindexedcoupon.cpp.

                                                 {
    ext::shared_ptr<OvernightIndex> index = ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
 
    const vector<Date>& fixingDates = coupon_->fixingDates();
    const vector<Time>& dt = coupon_->dt();
 
    Size n = dt.size();
    Size i = 0;
    QL_REQUIRE(coupon_->rateCutoff() < n, "rate cutoff (" << coupon_->rateCutoff()
                                                          << ") must be less than number of fixings in period (" << n
                                                          << ")");
    Size nCutoff = n - coupon_->rateCutoff();
 
    Real compoundFactor = 1.0, compoundFactorWithoutSpread = 1.0;
 
    // already fixed part
    Date today = Settings::instance().evaluationDate();
    while (i < n && fixingDates[std::min(i, nCutoff)] < today) {
        // rate must have been fixed
        Rate pastFixing = index->pastFixing(fixingDates[std::min(i, nCutoff)]);
        QL_REQUIRE(pastFixing != Null<Real>(),
                   "Missing " << index->name() << " fixing for " << fixingDates[std::min(i, nCutoff)]);
        if (coupon_->includeSpread()) {
            compoundFactorWithoutSpread *= (1.0 + pastFixing * dt[i]);
            pastFixing += coupon_->spread();
        }
        compoundFactor *= (1.0 + pastFixing * dt[i]);
        ++i;
    }
 
    // today is a border case
    if (i < n && fixingDates[std::min(i, nCutoff)] == today) {
        // might have been fixed
        try {
            Rate pastFixing = index->pastFixing(fixingDates[std::min(i, nCutoff)]);
            if (pastFixing != Null<Real>()) {
                if (coupon_->includeSpread()) {
                    compoundFactorWithoutSpread *= (1.0 + pastFixing * dt[i]);
                    pastFixing += coupon_->spread();
                }
                compoundFactor *= (1.0 + pastFixing * dt[i]);
                ++i;
            } else {
                ; // fall through and forecast
            }
        } catch (Error&) {
            ; // fall through and forecast
        }
    }
 
    // forward part using telescopic property in order
    // to avoid the evaluation of multiple forward fixings
    const vector<Date>& dates = coupon_->valueDates();
    if (i < n) {
        Handle<YieldTermStructure> curve = index->forwardingTermStructure();
        QL_REQUIRE(!curve.empty(), "null term structure set to this instance of " << index->name());
 
        // handle the part until the rate cutoff (might be empty, i.e. startDiscount = endDiscount)
        DiscountFactor startDiscount = curve->discount(dates[i]);
        DiscountFactor endDiscount = curve->discount(dates[std::max(nCutoff, i)]);
 
        // handle the rate cutoff period (if there is any, i.e. if nCutoff < n)
        if (nCutoff < n) {
            // forward discount factor for one calendar day on the cutoff date
            DiscountFactor discountCutoffDate = curve->discount(dates[nCutoff] + 1) / curve->discount(dates[nCutoff]);
            // keep the above forward discount factor constant during the cutoff period
            endDiscount *= std::pow(discountCutoffDate, dates[n] - dates[nCutoff]);
        }
 
        compoundFactor *= startDiscount / endDiscount;
 
        if (coupon_->includeSpread()) {
            compoundFactorWithoutSpread *= startDiscount / endDiscount;
            // this is an approximation, see "Ester / Daily Spread Curve Setup in ORE":
            // set tau to an average value
            Real tau = index->dayCounter().yearFraction(dates[i], dates.back()) / (dates.back() - dates[i]);
            // now use formula (4) from the paper
            compoundFactor *= std::pow(1.0 + tau * coupon_->spread(), static_cast<int>(dates.back() - dates[i]));
        }
    }
 
    Rate tau = index->dayCounter().yearFraction(dates.front(), dates.back());
    Rate rate = (compoundFactor - 1.0) / tau;
    swapletRate_ = coupon_->gearing() * rate;
    if (!coupon_->includeSpread()) {
        swapletRate_ += coupon_->spread();
        effectiveSpread_ = coupon_->spread();
        effectiveIndexFixing_ = rate;
    } else {
        effectiveSpread_ = rate - (compoundFactorWithoutSpread - 1.0) / tau;
        effectiveIndexFixing_ = rate - effectiveSpread_;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

swapletRate()

Rate swapletRate ( ) const

override

Definition at line 289 of file overnightindexedcoupon.cpp.

                                                     {
    compute();
    return swapletRate_;
}

Here is the call graph for this function:

effectiveSpread()

Rate effectiveSpread

(

)

const

Definition at line 294 of file overnightindexedcoupon.cpp.

                                                         {
    compute();
    return effectiveSpread_;
}

Here is the call graph for this function:

effectiveIndexFixing()

Rate effectiveIndexFixing

(

)

const

Definition at line 299 of file overnightindexedcoupon.cpp.

                                                              {
    compute();
    return effectiveIndexFixing_;
}

Here is the call graph for this function:

swapletPrice()

Real swapletPrice ( ) const

override

Definition at line 140 of file overnightindexedcoupon.hpp.

{ QL_FAIL("swapletPrice not available"); }

capletPrice()

Real capletPrice ( Rate  ) const

override

Definition at line 141 of file overnightindexedcoupon.hpp.

{ QL_FAIL("capletPrice not available"); }

capletRate()

Rate capletRate ( Rate  ) const

override

Definition at line 142 of file overnightindexedcoupon.hpp.

{ QL_FAIL("capletRate not available"); }

floorletPrice()

Real floorletPrice ( Rate  ) const

override

Definition at line 143 of file overnightindexedcoupon.hpp.

{ QL_FAIL("floorletPrice not available"); }

floorletRate()

Rate floorletRate ( Rate  ) const

override

Definition at line 144 of file overnightindexedcoupon.hpp.

{ QL_FAIL("floorletRate not available"); }

Member Data Documentation

coupon_

const OvernightIndexedCoupon* coupon_

protected

Definition at line 147 of file overnightindexedcoupon.hpp.

swapletRate_

Real swapletRate_

mutableprotected

Definition at line 148 of file overnightindexedcoupon.hpp.

effectiveSpread_

Real effectiveSpread_

protected

Definition at line 148 of file overnightindexedcoupon.hpp.

effectiveIndexFixing_

Real effectiveIndexFixing_

protected

Definition at line 148 of file overnightindexedcoupon.hpp.