DiscretizedConvertible Class Reference

#include <qle/pricingengines/discretizedconvertible.hpp>

Inheritance diagram for DiscretizedConvertible:

Collaboration diagram for DiscretizedConvertible:

Public Member Functions
	DiscretizedConvertible (const ConvertibleBond::option::arguments &args, const ext::shared_ptr< GeneralizedBlackScholesProcess > &process, const Handle< Quote > &creditSpread, const TimeGrid &grid)
void	reset (Size size) override
const Array &	conversionProbability () const
Array &	conversionProbability ()
const Array &	spreadAdjustedRate () const
Array &	spreadAdjustedRate ()
const Array &	dividendValues () const
Array &	dividendValues ()
std::vector< Time >	mandatoryTimes () const override

Protected Member Functions
void	postAdjustValuesImpl () override

Protected Attributes
Array	conversionProbability_
Array	spreadAdjustedRate_
Array	dividendValues_

Private Member Functions
Array	adjustedGrid () const
void	applyConvertibility ()
void	applyCallability (Size, bool convertible)
void	addCashflow (Size)
Real	getConversionRatio (const Real t) const

Private Attributes
ConvertibleBond::option::arguments	arguments_
QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess >	process_
Handle< Quote >	creditSpread_
std::vector< Time >	stoppingTimes_
std::vector< Time >	callabilityTimes_
std::vector< Time >	cashflowTimes_
std::vector< Time >	dividendTimes_
std::vector< Time >	notionalTimes_

Detailed Description

Definition at line 33 of file discretizedconvertible.hpp.

Constructor & Destructor Documentation

DiscretizedConvertible()

DiscretizedConvertible	(	const ConvertibleBond::option::arguments &	args,
		const ext::shared_ptr< GeneralizedBlackScholesProcess > &	process,
		const Handle< Quote > &	creditSpread,
		const TimeGrid &	grid
	)

Definition at line 27 of file discretizedconvertible.cpp.

    : arguments_(args), process_(process), creditSpread_(creditSpread) {
 
    dividendValues_ = Array(arguments_.dividends.size(), 0.0);
 
    Date settlementDate = process_->riskFreeRate()->referenceDate();
    for (Size i = 0; i < arguments_.dividends.size(); i++) {
        if (arguments_.dividends[i]->date() >= settlementDate) {
            dividendValues_[i] =
                arguments_.dividends[i]->amount() * process_->riskFreeRate()->discount(arguments_.dividends[i]->date());
        }
    }
 
    DayCounter dayCounter = process_->riskFreeRate()->dayCounter();
    Date bondSettlement = arguments_.settlementDate;
 
    stoppingTimes_.resize(arguments_.exercise->dates().size());
    for (Size i = 0; i < stoppingTimes_.size(); ++i)
        stoppingTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.exercise->date(i));
 
    callabilityTimes_.resize(arguments_.callabilityDates.size());
    for (Size i = 0; i < callabilityTimes_.size(); ++i)
        callabilityTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.callabilityDates[i]);
 
    cashflowTimes_.resize(arguments_.cashflowDates.size());
    for (Size i = 0; i < cashflowTimes_.size(); ++i) {
        cashflowTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.cashflowDates[i]);
    }
 
    dividendTimes_.resize(arguments_.dividendDates.size());
    for (Size i = 0; i < dividendTimes_.size(); ++i)
        dividendTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.dividendDates[i]);
 
    if (!grid.empty()) {
        // adjust times to grid
        for (Size i = 0; i < stoppingTimes_.size(); i++)
            stoppingTimes_[i] = grid.closestTime(stoppingTimes_[i]);
        for (Size i = 0; i < cashflowTimes_.size(); i++)
            cashflowTimes_[i] = grid.closestTime(cashflowTimes_[i]);
        for (Size i = 0; i < callabilityTimes_.size(); i++)
            callabilityTimes_[i] = grid.closestTime(callabilityTimes_[i]);
        for (Size i = 0; i < dividendTimes_.size(); i++)
            dividendTimes_[i] = grid.closestTime(dividendTimes_[i]);
    }
 
    notionalTimes_.clear();
    for (auto const& d : arguments_.notionalDates) {
        notionalTimes_.push_back(grid.closestTime(dayCounter.yearFraction(bondSettlement, d)));
    }
}

Member Function Documentation

reset()

void reset ( Size  size )

override

Definition at line 92 of file discretizedconvertible.cpp.

                                            {
 
    // Set cashflow on last date
    values_ = Array(size, 0.0);
    for (Size i = 0; i < cashflowTimes_.size(); ++i) {
        if (close_enough(cashflowTimes_[i], cashflowTimes_.back())) {
            values_ += arguments_.cashflowAmounts[i];
        }
    }
 
    conversionProbability_ = Array(size, 0.0);
    spreadAdjustedRate_ = Array(size, 0.0);
 
    DayCounter rfdc = process_->riskFreeRate()->dayCounter();
 
    // this takes care of convertibility and conversion probabilities
    adjustValues();
 
    Real creditSpread = creditSpread_->value();
    Rate riskFreeRate = process_->riskFreeRate()->zeroRate(arguments_.maturityDate, rfdc, Continuous, NoFrequency);
 
    // Calculate blended discount rate to be used on roll back.
    for (Size j = 0; j < values_.size(); j++) {
        spreadAdjustedRate_[j] =
            conversionProbability_[j] * riskFreeRate + (1 - conversionProbability_[j]) * (riskFreeRate + creditSpread);
    }
}

Here is the call graph for this function:

conversionProbability() [1/2]

const Array & conversionProbability

(

)

const

Definition at line 41 of file discretizedconvertible.hpp.

{ return conversionProbability_; }

Here is the caller graph for this function:

conversionProbability() [2/2]

Array & conversionProbability

(

)

Definition at line 42 of file discretizedconvertible.hpp.

{ return conversionProbability_; }

spreadAdjustedRate() [1/2]

const Array & spreadAdjustedRate

(

)

const

Definition at line 44 of file discretizedconvertible.hpp.

{ return spreadAdjustedRate_; }

Here is the caller graph for this function:

spreadAdjustedRate() [2/2]

Array & spreadAdjustedRate

(

)

Definition at line 45 of file discretizedconvertible.hpp.

{ return spreadAdjustedRate_; }

dividendValues() [1/2]

const Array & dividendValues

(

)

const

Definition at line 47 of file discretizedconvertible.hpp.

{ return dividendValues_; }

dividendValues() [2/2]

Array & dividendValues

(

)

Definition at line 48 of file discretizedconvertible.hpp.

{ return dividendValues_; }

mandatoryTimes()

std::vector< Time > mandatoryTimes ( ) const

override

Definition at line 80 of file discretizedconvertible.cpp.

                                                             {
    std::vector<Time> result;
    // the stopping times might be negative, if an exercise date lies in the past
    for (auto const& t : stoppingTimes_) {
        if (t > 0.0)
            result.push_back(t);
    }
    std::copy(callabilityTimes_.begin(), callabilityTimes_.end(), std::back_inserter(result));
    std::copy(cashflowTimes_.begin(), cashflowTimes_.end(), std::back_inserter(result));
    return result;
}

postAdjustValuesImpl()

void postAdjustValuesImpl ( )

overrideprotected

Definition at line 120 of file discretizedconvertible.cpp.

                                                  {
 
    bool convertible = false;
    switch (arguments_.exercise->type()) {
    case Exercise::American:
        if (time() <= stoppingTimes_[1] && time() >= stoppingTimes_[0])
            convertible = true;
        break;
    case Exercise::European:
        if (isOnTime(stoppingTimes_[0]))
            convertible = true;
        break;
    case Exercise::Bermudan:
        for (Size i = 0; i < stoppingTimes_.size(); ++i) {
            if (isOnTime(stoppingTimes_[i]))
                convertible = true;
        }
        break;
    default:
        QL_FAIL("invalid option type");
    }
 
    for (Size i = 0; i < callabilityTimes_.size(); i++) {
        if (isOnTime(callabilityTimes_[i]))
            applyCallability(i, convertible);
    }
 
    for (Size i = 0; i < cashflowTimes_.size(); i++) {
        if (isOnTime(cashflowTimes_[i]) && !close_enough(cashflowTimes_[i], cashflowTimes_.back()))
            addCashflow(i);
    }
 
    if (convertible)
        applyConvertibility();
}

Here is the call graph for this function:

adjustedGrid()

Array adjustedGrid ( ) const

private

Definition at line 215 of file discretizedconvertible.cpp.

                                                 {
    Time t = time();
    Array grid = method()->grid(t);
    // add back all dividend amounts in the future
    for (Size i = 0; i < arguments_.dividends.size(); i++) {
        Time dividendTime = dividendTimes_[i];
        if (dividendTime >= t || close(dividendTime, t)) {
            const ext::shared_ptr<Dividend>& d = arguments_.dividends[i];
            DiscountFactor dividendDiscount =
                process_->riskFreeRate()->discount(dividendTime) / process_->riskFreeRate()->discount(t);
            for (Size j = 0; j < grid.size(); j++)
                grid[j] += d->amount(grid[j]) * dividendDiscount;
        }
    }
    return grid;
}

Here is the caller graph for this function:

applyConvertibility()

void applyConvertibility ( )

private

Definition at line 164 of file discretizedconvertible.cpp.

                                                 {
    Array grid = adjustedGrid();
    Real conversionRatio = getConversionRatio(time());
    for (Size j = 0; j < values_.size(); j++) {
        Real payoff = conversionRatio * grid[j];
        if (values_[j] <= payoff) {
            values_[j] = payoff;
            conversionProbability_[j] = 1.0;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

applyCallability()

void applyCallability ( Size  i, bool  convertible  )

private

Definition at line 176 of file discretizedconvertible.cpp.

                                                                      {
    Size j;
    Array grid = adjustedGrid();
    Real conversionRatio = getConversionRatio(time());
    switch (arguments_.callabilityTypes[i]) {
    case Callability::Call:
        if (arguments_.callabilityTriggers[i] != Null<Real>() && arguments_.conversionValue != Null<Real>()) {
            Real trigger = arguments_.conversionValue * arguments_.callabilityTriggers[i];
            for (j = 0; j < values_.size(); j++) {
                // the callability is conditioned by the trigger...
                if (grid[j] >= trigger) {
                    // ...and might trigger conversion
                    values_[j] =
                        std::min(std::max(arguments_.callabilityPrices[i], conversionRatio * grid[j]), values_[j]);
                }
            }
        } else if (convertible) {
            for (j = 0; j < values_.size(); j++) {
                // exercising the callability might trigger conversion
                values_[j] = std::min(std::max(arguments_.callabilityPrices[i], conversionRatio * grid[j]), values_[j]);
            }
        } else {
            for (j = 0; j < values_.size(); j++) {
                values_[j] = std::min(arguments_.callabilityPrices[i], values_[j]);
            }
        }
        break;
    case Callability::Put:
        for (j = 0; j < values_.size(); j++) {
            values_[j] = std::max(values_[j], arguments_.callabilityPrices[i]);
        }
        break;
    default:
        QL_FAIL("unknown callability type");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

addCashflow()

void addCashflow ( Size  i )

private

Definition at line 213 of file discretizedconvertible.cpp.

{ values_ += arguments_.cashflowAmounts[i]; }

Here is the caller graph for this function:

getConversionRatio()

Real getConversionRatio ( const Real  t ) const

private

Definition at line 156 of file discretizedconvertible.cpp.

                                                                  {
    Size idx = std::distance(notionalTimes_.begin(), std::upper_bound(notionalTimes_.begin(), notionalTimes_.end(), t));
    if (idx > 0)
        --idx;
    return arguments_.notionals[std::min(idx, arguments_.notionals.size() - 1)] / arguments_.notionals.front() *
           arguments_.conversionRatio;
}

Here is the caller graph for this function:

Member Data Documentation

conversionProbability_

Array conversionProbability_

protected

Definition at line 54 of file discretizedconvertible.hpp.

spreadAdjustedRate_

Array spreadAdjustedRate_

protected

Definition at line 54 of file discretizedconvertible.hpp.

dividendValues_

Array dividendValues_

protected

Definition at line 54 of file discretizedconvertible.hpp.

arguments_

ConvertibleBond::option::arguments arguments_

private

Definition at line 61 of file discretizedconvertible.hpp.

process_

QuantLib::ext::shared_ptr<GeneralizedBlackScholesProcess> process_

private

Definition at line 62 of file discretizedconvertible.hpp.

creditSpread_

Handle<Quote> creditSpread_

private

Definition at line 63 of file discretizedconvertible.hpp.

stoppingTimes_

std::vector<Time> stoppingTimes_

private

Definition at line 64 of file discretizedconvertible.hpp.

callabilityTimes_

std::vector<Time> callabilityTimes_

private

Definition at line 65 of file discretizedconvertible.hpp.

cashflowTimes_

std::vector<Time> cashflowTimes_

private

Definition at line 66 of file discretizedconvertible.hpp.

dividendTimes_

std::vector<Time> dividendTimes_

private

Definition at line 67 of file discretizedconvertible.hpp.

notionalTimes_

std::vector<Time> notionalTimes_

private

Definition at line 71 of file discretizedconvertible.hpp.