ConvertibleBond::option Class Reference

#include <qle/instruments/convertiblebond.hpp>

Inheritance diagram for ConvertibleBond::option:

Collaboration diagram for ConvertibleBond::option:

Classes
class	arguments
class	engine

Public Member Functions
	option (const ConvertibleBond *bond)
void	setupArguments (PricingEngine::arguments *) const override
bool	isExpired () const override

Private Attributes
const ConvertibleBond *	bond_

Detailed Description

Definition at line 79 of file convertiblebond.hpp.

Constructor & Destructor Documentation

option()

option

(

const ConvertibleBond *

bond

)

Definition at line 62 of file convertiblebond.cpp.

    : OneAssetOption(QuantLib::ext::shared_ptr<StrikedTypePayoff>(
                         new PlainVanillaPayoff(Option::Call, bond->notionals().front() / bond->conversionRatio())),
                     bond->exercise()),
      bond_(bond) {
    registerWith(QuantLib::ext::shared_ptr<ConvertibleBond>(const_cast<ConvertibleBond*>(bond), null_deleter()));
}

Member Function Documentation

setupArguments()

void setupArguments ( PricingEngine::arguments *  args ) const

override

Definition at line 72 of file convertiblebond.cpp.

                                                                             {
 
    OneAssetOption::setupArguments(args);
 
    ConvertibleBond::option::arguments* moreArgs = dynamic_cast<ConvertibleBond::option::arguments*>(args);
    QL_REQUIRE(moreArgs != 0, "wrong argument type");
 
    moreArgs->conversionRatio = bond_->conversionRatio();
    moreArgs->conversionValue = close_enough(bond_->conversionRatio(), 0.0)
                                    ? Null<Real>()
                                    : bond_->notionals().front() / bond_->conversionRatio();
 
    Date settlement = bond_->settlementDate();
 
    Size n = bond_->callability().size();
    moreArgs->callabilityDates.clear();
    moreArgs->callabilityTypes.clear();
    moreArgs->callabilityPrices.clear();
    moreArgs->callabilityTriggers.clear();
    moreArgs->callabilityDates.reserve(n);
    moreArgs->callabilityTypes.reserve(n);
    moreArgs->callabilityPrices.reserve(n);
    moreArgs->callabilityTriggers.reserve(n);
    for (Size i = 0; i < n; i++) {
        if (!bond_->callability()[i]->hasOccurred(settlement, false)) {
            moreArgs->callabilityTypes.push_back(bond_->callability()[i]->type());
            moreArgs->callabilityDates.push_back(bond_->callability()[i]->date());
            moreArgs->callabilityPrices.push_back(bond_->callability()[i]->price().amount() *
                                                  bond_->notional(bond_->callability()[i]->date()));
            if (bond_->callability()[i]->price().type() == Bond::Price::Clean)
                moreArgs->callabilityPrices.back() += bond_->accruedAmount(bond_->callability()[i]->date()) / 100.0 *
                                                      bond_->notional(bond_->callability()[i]->date());
            QuantLib::ext::shared_ptr<SoftCallability> softCall =
                QuantLib::ext::dynamic_pointer_cast<SoftCallability>(bond_->callability()[i]);
            if (softCall)
                moreArgs->callabilityTriggers.push_back(softCall->trigger());
            else
                moreArgs->callabilityTriggers.push_back(Null<Real>());
        }
    }
 
    const Leg& cashflows = bond_->cashflows();
 
    moreArgs->cashflowDates.clear();
    moreArgs->cashflowAmounts.clear();
    for (Size i = 0; i < cashflows.size(); i++) {
        if (!cashflows[i]->hasOccurred(settlement, false)) {
            moreArgs->cashflowDates.push_back(cashflows[i]->date());
            moreArgs->cashflowAmounts.push_back(cashflows[i]->amount());
        }
    }
 
    moreArgs->notionals.clear();
    moreArgs->notionalDates.clear();
    Real currentNotional = 0.0;
    for (std::vector<QuantLib::ext::shared_ptr<CashFlow>>::const_reverse_iterator r = bond_->redemptions().rbegin();
         r != bond_->redemptions().rend(); ++r) {
        moreArgs->notionals.insert(moreArgs->notionals.begin(), currentNotional);
        moreArgs->notionalDates.insert(moreArgs->notionalDates.begin(), (*r)->date());
        currentNotional += (*r)->amount();
    }
    moreArgs->notionals.insert(moreArgs->notionals.begin(), currentNotional);
    moreArgs->notionalDates.insert(moreArgs->notionalDates.begin(), settlement);
 
    moreArgs->dividends.clear();
    moreArgs->dividendDates.clear();
    for (Size i = 0; i < bond_->dividends().size(); i++) {
        if (!bond_->dividends()[i]->hasOccurred(settlement, false)) {
            moreArgs->dividends.push_back(bond_->dividends()[i]);
            moreArgs->dividendDates.push_back(bond_->dividends()[i]->date());
        }
    }
 
    moreArgs->issueDate = bond_->issueDate();
    moreArgs->settlementDate = bond_->settlementDate();
    moreArgs->settlementDays = bond_->settlementDays();
    moreArgs->maturityDate = bond_->maturityDate();
}

Here is the call graph for this function:

isExpired()

bool isExpired ( ) const

override

Definition at line 70 of file convertiblebond.cpp.

{ return bond_->isExpired(); }

Member Data Documentation

bond_

const ConvertibleBond* bond_

private

Definition at line 90 of file convertiblebond.hpp.