capped floored overnight indexed coupon More...

#include <qle/cashflows/overnightindexedcoupon.hpp>

Inheritance diagram for CappedFlooredOvernightIndexedCoupon:

Collaboration diagram for CappedFlooredOvernightIndexedCoupon:

Public Member Functions
	CappedFlooredOvernightIndexedCoupon (const ext::shared_ptr< OvernightIndexedCoupon > &underlying, Real cap=Null< Real >(), Real floor=Null< Real >(), bool nakedOption=false, bool localCapFloor=false)

Observer interface
void	deepUpdate () override

LazyObject interface
void	performCalculations () const override

void	alwaysForwardNotifications () override

Coupon interface
Rate	rate () const override

Rate	convexityAdjustment () const override

FloatingRateCoupon interface
Date	fixingDate () const override

Rate	cap () const
	cap More...

Rate	floor () const
	floor More...

Rate	effectiveCap () const
	effective cap of fixing More...

Rate	effectiveFloor () const
	effective floor of fixing More...

Real	effectiveCapletVolatility () const
	effective caplet volatility More...

Real	effectiveFloorletVolatility () const
	effective floorlet volatility More...

Visitability
ext::shared_ptr< OvernightIndexedCoupon >	underlying_

Rate	cap_

Rate	floor_

bool	nakedOption_

bool	localCapFloor_

Real	effectiveCapletVolatility_

Real	effectiveFloorletVolatility_

virtual void	accept (AcyclicVisitor &) override

bool	isCapped () const

bool	isFloored () const

ext::shared_ptr< OvernightIndexedCoupon >	underlying () const

bool	nakedOption () const

bool	localCapFloor () const

Detailed Description

capped floored overnight indexed coupon

Definition at line 152 of file overnightindexedcoupon.hpp.

Constructor & Destructor Documentation

◆ CappedFlooredOvernightIndexedCoupon()

CappedFlooredOvernightIndexedCoupon	(	const ext::shared_ptr< OvernightIndexedCoupon > &	underlying,
		Real	cap = `Null<Real>()`,
		Real	floor = `Null<Real>()`,
		bool	nakedOption = `false`,
		bool	localCapFloor = `false`
	)

capped / floored compounded, backward-looking on coupon, local means that the daily rates are capped / floored while a global cap / floor is applied to the effective period rate

Definition at line 306 of file overnightindexedcoupon.cpp.

    : FloatingRateCoupon(underlying->date(), underlying->nominal(), underlying->accrualStartDate(),
                         underlying->accrualEndDate(), underlying->fixingDays(), underlying->index(),
                         underlying->gearing(), underlying->spread(), underlying->referencePeriodStart(),
                         underlying->referencePeriodEnd(), underlying->dayCounter(), false),
      underlying_(underlying), nakedOption_(nakedOption), localCapFloor_(localCapFloor) {
 
    QL_REQUIRE(!underlying_->includeSpread() || close_enough(underlying_->gearing(), 1.0),
               "CappedFlooredOvernightIndexedCoupon: if include spread = true, only a gearing 1.0 is allowed - scale "
               "the notional in this case instead.");
 
    if (!localCapFloor) {
        if (gearing_ > 0.0) {
            cap_ = cap;
            floor_ = floor;
        } else {
            cap_ = floor;
            floor_ = cap;
        }
    } else {
        cap_ = cap;
        floor_ = floor;
    }
    if (cap_ != Null<Real>() && floor_ != Null<Real>()) {
        QL_REQUIRE(cap_ >= floor, "cap level (" << cap_ << ") less than floor level (" << floor_ << ")");
    }
    registerWith(underlying_);
    if (nakedOption_)
        underlying_->alwaysForwardNotifications();
}

Here is the call graph for this function:

Member Function Documentation

◆ deepUpdate()

void deepUpdate ( )

override

Definition at line 344 of file overnightindexedcoupon.cpp.

                                                     {
    update();
    underlying_->deepUpdate();
}

◆ performCalculations()

void performCalculations ( ) const

override

Definition at line 349 of file overnightindexedcoupon.cpp.

                                                                    {
    QL_REQUIRE(underlying_->pricer(), "pricer not set");
    Rate swapletRate = nakedOption_ ? 0.0 : underlying_->rate();
    if (floor_ != Null<Real>() || cap_ != Null<Real>())
        pricer()->initialize(*this);
    Rate floorletRate = 0.;
    if (floor_ != Null<Real>())
        floorletRate = pricer()->floorletRate(effectiveFloor());
    Rate capletRate = 0.;
    if (cap_ != Null<Real>())
        capletRate = (nakedOption_ && floor_ == Null<Real>() ? -1.0 : 1.0) * pricer()->capletRate(effectiveCap());
    rate_ = swapletRate + floorletRate - capletRate;
    auto p = QuantLib::ext::dynamic_pointer_cast<CappedFlooredOvernightIndexedCouponPricer>(pricer());
    QL_REQUIRE(p, "CappedFlooredOvernightIndexedCoupon::performCalculations(): internal error, could not cast to "
                  "CappedFlooredOvernightIndexedCouponPricer");
    effectiveCapletVolatility_ = p->effectiveCapletVolatility();
    effectiveFloorletVolatility_ = p->effectiveFloorletVolatility();
}

Here is the call graph for this function:

◆ alwaysForwardNotifications()

void alwaysForwardNotifications ( )

override

Definition at line 339 of file overnightindexedcoupon.cpp.

                                                                     {
    LazyObject::alwaysForwardNotifications();
    underlying_->alwaysForwardNotifications();
}

◆ rate()

Rate rate ( ) const

override

Definition at line 372 of file overnightindexedcoupon.cpp.

                                                     {
    calculate();
    return rate_;
}

◆ convexityAdjustment()

Rate convexityAdjustment ( ) const

override

Definition at line 377 of file overnightindexedcoupon.cpp.

377{ return underlying_->convexityAdjustment(); }

◆ fixingDate()

Date fixingDate ( ) const

override

Definition at line 176 of file overnightindexedcoupon.hpp.

176{ return underlying_->fixingDate(); }

◆ cap()

Rate cap ( ) const

cap

Definition at line 368 of file overnightindexedcoupon.cpp.

368{ return gearing_ > 0.0 ? cap_ : floor_; }

Here is the caller graph for this function:

◆ floor()

Rate floor ( ) const

floor

Definition at line 370 of file overnightindexedcoupon.cpp.

370{ return gearing_ > 0.0 ? floor_ : cap_; }

Here is the caller graph for this function:

◆ effectiveCap()

Rate effectiveCap ( ) const

effective cap of fixing

Definition at line 379 of file overnightindexedcoupon.cpp.

                                                             {
    if (cap_ == Null<Real>())
        return Null<Real>();
    /* We have four cases dependent on localCapFloor_ and includeSpread. Notation in the formulas:
       g         gearing,
       s         spread,
       A         coupon amount,
       f_i       daily fixings,
       \tau_i    daily accrual fractions,
       \tau      coupon accrual fraction,
       C         cap rate
       F         floor rate
    */
    if (localCapFloor_) {
        if (underlying_->includeSpread()) {
            // A = g \cdot \frac{\prod (1 + \tau_i \min ( \max ( f_i + s , F), C)) - 1}{\tau}
            return cap_ - underlying_->spread();
        } else {
            // A = g \cdot \frac{\prod (1 + \tau_i \min ( \max ( f_i , F), C)) - 1}{\tau} + s
            return cap_;
        }
    } else {
        if (underlying_->includeSpread()) {
            // A = \min \left( \max \left( g \cdot \frac{\prod (1 + \tau_i(f_i + s)) - 1}{\tau}, F \right), C \right)
            return (cap_ / gearing() - underlying_->effectiveSpread());
        } else {
            // A = \min \left( \max \left( g \cdot \frac{\prod (1 + \tau_i f_i) - 1}{\tau} + s, F \right), C \right)
            return (cap_ - underlying_->effectiveSpread()) / gearing();
        }
    }
}

Here is the caller graph for this function:

◆ effectiveFloor()

Rate effectiveFloor ( ) const

effective floor of fixing

Definition at line 411 of file overnightindexedcoupon.cpp.

                                                               {
    if (floor_ == Null<Real>())
        return Null<Real>();
    if (localCapFloor_) {
        if (underlying_->includeSpread()) {
            return floor_ - underlying_->spread();
        } else {
            return floor_;
        }
    } else {
        if (underlying_->includeSpread()) {
            return (floor_ - underlying_->effectiveSpread());
        } else {
            return (floor_ - underlying_->effectiveSpread()) / gearing();
        }
    }
}

Here is the caller graph for this function:

◆ effectiveCapletVolatility()

Real effectiveCapletVolatility ( ) const

effective caplet volatility

Definition at line 429 of file overnightindexedcoupon.cpp.

                                                                          {
    calculate();
    return effectiveCapletVolatility_;
}

◆ effectiveFloorletVolatility()

Real effectiveFloorletVolatility ( ) const

effective floorlet volatility

Definition at line 434 of file overnightindexedcoupon.cpp.

                                                                            {
    calculate();
    return effectiveFloorletVolatility_;
}

◆ accept()

void accept ( AcyclicVisitor & v )

overridevirtual

Definition at line 439 of file overnightindexedcoupon.cpp.

                                                                  {
    Visitor<CappedFlooredOvernightIndexedCoupon>* v1 = dynamic_cast<Visitor<CappedFlooredOvernightIndexedCoupon>*>(&v);
    if (v1 != 0)
        v1->visit(*this);
    else
        FloatingRateCoupon::accept(v);
}