FdConvertibleBondEvents Class Reference

#include <qle/pricingengines/fdconvertiblebondevents.hpp>

Collaboration diagram for FdConvertibleBondEvents:

Classes
struct	CallData
struct	ConversionData
struct	ConversionResetData
struct	DividendPassThroughData
struct	MandatoryConversionData

Public Member Functions
	FdConvertibleBondEvents (const Date &today, const DayCounter &dc, const Real N0, const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &equity, const QuantLib::ext::shared_ptr< FxIndex > &fxConversion)
void	registerBondCashflow (const QuantLib::ext::shared_ptr< CashFlow > &c)
void	registerCall (const ConvertibleBond2::CallabilityData &c)
void	registerMakeWhole (const ConvertibleBond2::MakeWholeData &c)
void	registerPut (const ConvertibleBond2::CallabilityData &c)
void	registerConversionRatio (const ConvertibleBond2::ConversionRatioData &c)
void	registerConversion (const ConvertibleBond2::ConversionData &c)
void	registerMandatoryConversion (const ConvertibleBond2::MandatoryConversionData &c)
void	registerConversionReset (const ConvertibleBond2::ConversionResetData &c)
void	registerDividendProtection (const ConvertibleBond2::DividendProtectionData &c)
const std::set< Real > &	times () const
void	finalise (const TimeGrid &grid)
bool	hasBondCashflow (const Size i) const
bool	hasCall (const Size i) const
bool	hasPut (const Size i) const
bool	hasConversion (const Size i) const
bool	hasMandatoryConversion (const Size i) const
bool	hasContingentConversion (const Size i) const
bool	hasNoConversionPlane (const Size i) const
bool	hasConversionReset (const Size i) const
bool	hasDividendPassThrough (const Size i) const
Real	getBondCashflow (const Size i) const
Real	getBondFinalRedemption (const Size i) const
const CallData &	getCallData (const Size i) const
const CallData &	getPutData (const Size i) const
const ConversionData &	getConversionData (const Size i) const
const MandatoryConversionData &	getMandatoryConversionData (const Size i) const
const ConversionResetData &	getConversionResetData (const Size i) const
const DividendPassThroughData &	getDividendPassThroughData (const Size i) const
bool	hasStochasticConversionRatio (const Size i) const
Real	getInitialConversionRatio () const
Real	getCurrentConversionRatio (const Size i) const
Real	getCurrentFxConversion (const Size i) const
Date	getAssociatedDate (const Size i) const
const std::map< std::string, boost::any > &	additionalResults () const

Private Member Functions
Date	nextExerciseDate (const Date &d, const std::vector< ConvertibleBond2::CallabilityData > &data) const
Date	nextConversionDate (const Date &d) const
Real	time (const Date &d) const
void	processBondCashflows ()
void	processExerciseData (const std::vector< ConvertibleBond2::CallabilityData > &sourceData, std::vector< bool > &targetFlags, std::vector< CallData > &targetData)
void	processMakeWholeData ()
void	processConversionAndDivProtData ()
void	processMandatoryConversionData ()

Private Attributes
Date	today_
DayCounter	dc_
Real	N0_
QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 >	equity_
QuantLib::ext::shared_ptr< FxIndex >	fxConversion_
std::set< Real >	times_
TimeGrid	grid_
bool	finalised_ = false
Date	lastRedemptionDate_
std::vector< QuantLib::ext::shared_ptr< CashFlow > >	registeredBondCashflows_
std::vector< ConvertibleBond2::CallabilityData >	registeredCallData_
std::vector< ConvertibleBond2::CallabilityData >	registeredPutData_
std::vector< ConvertibleBond2::ConversionRatioData >	registeredConversionRatioData_
std::vector< ConvertibleBond2::ConversionData >	registeredConversionData_
std::vector< ConvertibleBond2::MandatoryConversionData >	registeredMandatoryConversionData_
std::vector< ConvertibleBond2::ConversionResetData >	registeredConversionResetData_
std::vector< ConvertibleBond2::DividendProtectionData >	registeredDividendProtectionData_
ConvertibleBond2::MakeWholeData	registeredMakeWholeData_
std::vector< bool >	hasBondCashflow_
std::vector< bool >	hasCall_
std::vector< bool >	hasPut_
std::vector< bool >	hasConversion_
std::vector< bool >	hasMandatoryConversion_
std::vector< bool >	hasContingentConversion_
std::vector< bool >	hasConversionInfoSet_
std::vector< bool >	hasNoConversionPlane_
std::vector< bool >	hasConversionReset_
std::vector< bool >	hasDividendPassThrough_
std::vector< Real >	bondCashflow_
std::vector< Real >	bondFinalRedemption_
std::vector< CallData >	callData_
std::vector< CallData >	putData_
std::vector< ConversionData >	conversionData_
std::vector< MandatoryConversionData >	mandatoryConversionData_
std::vector< ConversionResetData >	conversionResetData_
std::vector< DividendPassThroughData >	dividendPassThroughData_
std::vector< bool >	stochasticConversionRatio_
Real	initialConversionRatio_
std::vector< Real >	currentConversionRatio_
std::vector< Real >	currentFxConversion_
std::vector< Date >	associatedDate_
std::map< std::string, boost::any >	additionalResults_
QuantLib::Array	mw_cr_inc_x_
QuantLib::Array	mw_cr_inc_y_
QuantLib::Matrix	mw_cr_inc_z_

Detailed Description

Definition at line 37 of file fdconvertiblebondevents.hpp.

Constructor & Destructor Documentation

FdConvertibleBondEvents()

FdConvertibleBondEvents	(	const Date &	today,
		const DayCounter &	dc,
		const Real	N0,
		const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &	equity,
		const QuantLib::ext::shared_ptr< FxIndex > &	fxConversion
	)

Definition at line 36 of file fdconvertiblebondevents.cpp.

    : today_(today), dc_(dc), N0_(N0), equity_(equity), fxConversion_(fxConversion) {}

Member Function Documentation

registerBondCashflow()

void registerBondCashflow

(

const QuantLib::ext::shared_ptr< CashFlow > &

c

)

Definition at line 43 of file fdconvertiblebondevents.cpp.

                                                                                           {
    if (c->date() > today_) {
        registeredBondCashflows_.push_back(c);
        times_.insert(time(c->date()));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerCall()

void registerCall

(

const ConvertibleBond2::CallabilityData &

c

)

Definition at line 50 of file fdconvertiblebondevents.cpp.

                                                                                   {
    registeredCallData_.push_back(c);
    if (c.exerciseDate > today_) {
        times_.insert(time(c.exerciseDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerMakeWhole()

void registerMakeWhole

(

const ConvertibleBond2::MakeWholeData &

c

)

Definition at line 57 of file fdconvertiblebondevents.cpp.

                                                                                      {
    registeredMakeWholeData_ = d;
}

Here is the caller graph for this function:

registerPut()

void registerPut

(

const ConvertibleBond2::CallabilityData &

c

)

Definition at line 61 of file fdconvertiblebondevents.cpp.

                                                                                  {
    registeredPutData_.push_back(c);
    if (c.exerciseDate > today_) {
        times_.insert(time(c.exerciseDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerConversionRatio()

void registerConversionRatio

(

const ConvertibleBond2::ConversionRatioData &

c

)

Definition at line 68 of file fdconvertiblebondevents.cpp.

                                                                                                  {
    registeredConversionRatioData_.push_back(c);
    if (c.fromDate > today_) {
        times_.insert(time(c.fromDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerConversion()

void registerConversion

(

const ConvertibleBond2::ConversionData &

c

)

Definition at line 75 of file fdconvertiblebondevents.cpp.

                                                                                        {
    registeredConversionData_.push_back(c);
    if (c.exerciseDate > today_) {
        times_.insert(time(c.exerciseDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerMandatoryConversion()

void registerMandatoryConversion

(

const ConvertibleBond2::MandatoryConversionData &

c

)

Definition at line 82 of file fdconvertiblebondevents.cpp.

                                                                                                          {
    registeredMandatoryConversionData_.push_back(c);
    if (c.exerciseDate > today_) {
        times_.insert(time(c.exerciseDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerConversionReset()

void registerConversionReset

(

const ConvertibleBond2::ConversionResetData &

c

)

Definition at line 89 of file fdconvertiblebondevents.cpp.

                                                                                                  {
    registeredConversionResetData_.push_back(c);
    if (c.resetDate > today_) {
        times_.insert(time(c.resetDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerDividendProtection()

void registerDividendProtection

(

const ConvertibleBond2::DividendProtectionData &

c

)

Definition at line 96 of file fdconvertiblebondevents.cpp.

                                                                                                        {
    registeredDividendProtectionData_.push_back(c);
    if (c.protectionDate > today_) {
        times_.insert(time(c.protectionDate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

times()

const std::set< Real > & times

(

)

const

Definition at line 103 of file fdconvertiblebondevents.cpp.

{ return times_; }

Here is the caller graph for this function:

finalise()

void finalise

(

const TimeGrid &

grid

)

Definition at line 571 of file fdconvertiblebondevents.cpp.

                                                           {
    QL_REQUIRE(!finalised_, "FdConvertibleBondEvents: internal error, events already finalised");
    finalised_ = true;
    grid_ = grid;
 
    hasBondCashflow_.resize(grid.size(), false);
    hasCall_.resize(grid.size(), false);
    hasPut_.resize(grid.size(), false);
    hasConversion_.resize(grid.size(), false);
    hasMandatoryConversion_.resize(grid.size(), false);
    hasContingentConversion_.resize(grid.size(), false);
    hasConversionInfoSet_.resize(grid.size(), false);
    hasNoConversionPlane_.resize(grid.size(), false);
    hasConversionReset_.resize(grid.size(), false);
    hasDividendPassThrough_.resize(grid.size(), false);
 
    bondCashflow_.resize(grid.size(), 0.0);
    bondFinalRedemption_.resize(grid.size(), 0.0);
    callData_.resize(grid.size());
    putData_.resize(grid.size());
    conversionData_.resize(grid.size());
    conversionResetData_.resize(grid.size());
    dividendPassThroughData_.resize(grid.size());
    mandatoryConversionData_.resize(grid.size());
 
    stochasticConversionRatio_.resize(grid.size(), false);
    currentConversionRatio_.resize(grid.size(), 0.0);
    currentFxConversion_.resize(grid.size(), 1.0);
    associatedDate_.resize(grid.size(), Null<Date>());
 
    initialConversionRatio_ = 0.0;
 
    // fill fx conversion rate on grid
 
    if (fxConversion_ != nullptr) {
        auto source = fxConversion_->sourceCurve();
        auto target = fxConversion_->targetCurve();
        Real spot = fxConversion_->fixing(today_);
        for (Size i = 0; i < grid_.size(); ++i) {
            Real fx = spot * source->discount(grid_[i]) / target->discount(grid_[i]);
            currentFxConversion_[i] = fx;
        }
    }
 
    // process data
 
    processBondCashflows();
    processExerciseData(registeredCallData_, hasCall_, callData_);
    processExerciseData(registeredPutData_, hasPut_, putData_);
    processMakeWholeData();
    processConversionAndDivProtData();
    processMandatoryConversionData();
 
    // checks
 
    Size lastRedemptionIndex = grid_.index(time(lastRedemptionDate_));
    for (Size k = lastRedemptionIndex + 1; k < grid_.size(); ++k) {
        QL_REQUIRE(!hasConversion(k) && !hasMandatoryConversion(k),
                   "FdConvertibleBondEvents: conversion right after last bond redemption flow not allowed");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

hasBondCashflow()

bool hasBondCashflow

(

const Size

i

)

const

Definition at line 633 of file fdconvertiblebondevents.cpp.

{ return hasBondCashflow_.at(i); }

Here is the caller graph for this function:

hasCall()

bool hasCall

(

const Size

i

)

const

Definition at line 634 of file fdconvertiblebondevents.cpp.

{ return hasCall_.at(i); }

Here is the caller graph for this function:

hasPut()

bool hasPut

(

const Size

i

)

const

Definition at line 635 of file fdconvertiblebondevents.cpp.

{ return hasPut_.at(i); }

Here is the caller graph for this function:

hasConversion()

bool hasConversion

(

const Size

i

)

const

Definition at line 636 of file fdconvertiblebondevents.cpp.

{ return hasConversion_.at(i); }

Here is the caller graph for this function:

hasMandatoryConversion()

bool hasMandatoryConversion

(

const Size

i

)

const

Definition at line 637 of file fdconvertiblebondevents.cpp.

{ return hasMandatoryConversion_.at(i); }

Here is the caller graph for this function:

hasContingentConversion()

bool hasContingentConversion

(

const Size

i

)

const

Definition at line 638 of file fdconvertiblebondevents.cpp.

{ return hasContingentConversion_.at(i); }

Here is the caller graph for this function:

hasNoConversionPlane()

bool hasNoConversionPlane

(

const Size

i

)

const

Definition at line 639 of file fdconvertiblebondevents.cpp.

{ return hasNoConversionPlane_.at(i); }

Here is the caller graph for this function:

hasConversionReset()

bool hasConversionReset

(

const Size

i

)

const

Definition at line 640 of file fdconvertiblebondevents.cpp.

{ return hasConversionReset_.at(i); }

Here is the caller graph for this function:

hasDividendPassThrough()

bool hasDividendPassThrough

(

const Size

i

)

const

Definition at line 641 of file fdconvertiblebondevents.cpp.

{ return hasDividendPassThrough_.at(i); }

Here is the caller graph for this function:

getBondCashflow()

Real getBondCashflow

(

const Size

i

)

const

Definition at line 643 of file fdconvertiblebondevents.cpp.

{ return bondCashflow_.at(i); }

Here is the caller graph for this function:

getBondFinalRedemption()

Real getBondFinalRedemption

(

const Size

i

)

const

Definition at line 644 of file fdconvertiblebondevents.cpp.

{ return bondFinalRedemption_.at(i); }

Here is the caller graph for this function:

getCallData()

const FdConvertibleBondEvents::CallData & getCallData

(

const Size

i

)

const

Definition at line 646 of file fdconvertiblebondevents.cpp.

                                                                                              {
    return callData_.at(i);
}

Here is the caller graph for this function:

getPutData()

const FdConvertibleBondEvents::CallData & getPutData

(

const Size

i

)

const

Definition at line 650 of file fdconvertiblebondevents.cpp.

                                                                                             {
    return putData_.at(i);
}

Here is the caller graph for this function:

getConversionData()

const FdConvertibleBondEvents::ConversionData & getConversionData

(

const Size

i

)

const

Definition at line 654 of file fdconvertiblebondevents.cpp.

                                                                                                          {
    return conversionData_.at(i);
}

Here is the caller graph for this function:

getMandatoryConversionData()

const FdConvertibleBondEvents::MandatoryConversionData & getMandatoryConversionData

(

const Size

i

)

const

Definition at line 659 of file fdconvertiblebondevents.cpp.

                                                                      {
    return mandatoryConversionData_.at(i);
}

Here is the caller graph for this function:

getConversionResetData()

const FdConvertibleBondEvents::ConversionResetData & getConversionResetData

(

const Size

i

)

const

Definition at line 664 of file fdconvertiblebondevents.cpp.

                                                                  {
    return conversionResetData_.at(i);
}

Here is the caller graph for this function:

getDividendPassThroughData()

const FdConvertibleBondEvents::DividendPassThroughData & getDividendPassThroughData

(

const Size

i

)

const

Definition at line 669 of file fdconvertiblebondevents.cpp.

                                                                      {
    return dividendPassThroughData_.at(i);
}

Here is the caller graph for this function:

hasStochasticConversionRatio()

bool hasStochasticConversionRatio

(

const Size

i

)

const

Definition at line 673 of file fdconvertiblebondevents.cpp.

                                                                             {
    return stochasticConversionRatio_.at(i);
}

Here is the caller graph for this function:

getInitialConversionRatio()

Real getInitialConversionRatio

(

)

const

Definition at line 679 of file fdconvertiblebondevents.cpp.

{ return initialConversionRatio_; }

Here is the caller graph for this function:

getCurrentConversionRatio()

Real getCurrentConversionRatio

(

const Size

i

)

const

Definition at line 677 of file fdconvertiblebondevents.cpp.

{ return currentConversionRatio_.at(i); }

Here is the caller graph for this function:

getCurrentFxConversion()

Real getCurrentFxConversion

(

const Size

i

)

const

Definition at line 678 of file fdconvertiblebondevents.cpp.

{ return currentFxConversion_.at(i); }

Here is the caller graph for this function:

getAssociatedDate()

Date getAssociatedDate

(

const Size

i

)

const

Definition at line 680 of file fdconvertiblebondevents.cpp.

{ return associatedDate_.at(i); }

Here is the caller graph for this function:

additionalResults()

const std::map< std::string, boost::any > & additionalResults

(

)

const

Definition at line 150 of file fdconvertiblebondevents.hpp.

{ return additionalResults_; }

Here is the caller graph for this function:

nextExerciseDate()

Date nextExerciseDate ( const Date &  d, const std::vector< ConvertibleBond2::CallabilityData > &  data  ) const

private

Definition at line 105 of file fdconvertiblebondevents.cpp.

                                                                                                             {
    Date result = Date::maxDate();
    for (auto const& x : data) {
        if (x.exerciseDate > d)
            result = std::min(result, x.exerciseDate);
    }
    if (result == Date::maxDate())
        return Null<Date>();
    return result;
}

Here is the caller graph for this function:

nextConversionDate()

Date nextConversionDate ( const Date &  d ) const

private

Definition at line 117 of file fdconvertiblebondevents.cpp.

                                                                    {
    Date result = Date::maxDate();
    for (auto const& x : registeredConversionData_) {
        if (x.exerciseDate > d)
            result = std::min(result, x.exerciseDate);
    }
    if (result == Date::maxDate())
        return Null<Date>();
    return result;
}

Here is the caller graph for this function:

time()

Real time ( const Date &  d ) const

private

Definition at line 41 of file fdconvertiblebondevents.cpp.

{ return dc_.yearFraction(today_, d); }

Here is the caller graph for this function:

processBondCashflows()

void processBondCashflows ( )

private

Definition at line 128 of file fdconvertiblebondevents.cpp.

                                                   {
    lastRedemptionDate_ = Date::minDate();
    for (auto const& c : registeredBondCashflows_) {
        if (QuantLib::ext::dynamic_pointer_cast<Coupon>(c) == nullptr)
            lastRedemptionDate_ = std::max(lastRedemptionDate_, c->date());
    }
    for (auto const& d : registeredBondCashflows_) {
        bool isRedemption = QuantLib::ext::dynamic_pointer_cast<Coupon>(d) == nullptr;
        Size index = grid_.index(time(d->date()));
        hasBondCashflow_[index] = true;
        associatedDate_[index] = d->date();
        if (isRedemption && d->date() == lastRedemptionDate_)
            bondFinalRedemption_[index] += d->amount();
        else
            bondCashflow_[index] += d->amount();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

processExerciseData()

void processExerciseData ( const std::vector< ConvertibleBond2::CallabilityData > &  sourceData, std::vector< bool > &  targetFlags, std::vector< CallData > &  targetData  )

private

Definition at line 146 of file fdconvertiblebondevents.cpp.

                                                                                                                 {
    for (auto const& c : sourceData) {
        if (c.exerciseDate <= today_ && c.exerciseType == ConvertibleBond2::CallabilityData::ExerciseType::OnThisDate)
            continue;
        Size indexStart = grid_.index(time(std::max(c.exerciseDate, today_)));
        Size indexEnd;
        associatedDate_[indexStart] = std::max(c.exerciseDate, today_);
        if (c.exerciseType == ConvertibleBond2::CallabilityData::ExerciseType::OnThisDate) {
            indexEnd = indexStart;
        } else if (c.exerciseType == ConvertibleBond2::CallabilityData::ExerciseType::FromThisDateOn) {
            Date nextDate = nextExerciseDate(c.exerciseDate, sourceData);
            QL_REQUIRE(nextDate != Null<Date>(),
                       "FdConvertibleBondEvents::processExerciseData(): internal error: did not find a next exercise "
                       "date after "
                           << c.exerciseDate
                           << ", the last exercise date should not have exercise type FromThisDateOn");
            if (nextDate <= today_)
                continue;
            indexEnd = grid_.index(time(nextDate)) - 1;
        } else {
            QL_FAIL("FdConvertibleBondEvents: internal error, exercise type not "
                    "recognized");
        }
        for (Size i = indexStart; i <= indexEnd; ++i) {
            targetFlags[i] = true;
            targetData[i] = CallData{c.price,  c.priceType,        c.includeAccrual,
                                     c.isSoft, c.softTriggerRatio, std::function<Real(Real, Real)>()};
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

processMakeWholeData()

void processMakeWholeData ( )

private

Definition at line 178 of file fdconvertiblebondevents.cpp.

                                                   {
    if (registeredMakeWholeData_.crIncreaseData) {
 
        // init and checks
 
        auto const& stockPrices = (*registeredMakeWholeData_.crIncreaseData).stockPrices;
        auto const& effDates = (*registeredMakeWholeData_.crIncreaseData).effectiveDates;
        auto const& crInc = (*registeredMakeWholeData_.crIncreaseData).crIncrease;
        QL_REQUIRE(stockPrices.size() >= 2,
                   "FdConvertibleBondEvents::processMakeWholeData(): at least two stock prices required (cr increase)");
        QL_REQUIRE(
            effDates.size() >= 2,
            "FdConvertibleBondEvents::processMakeWholeData(): at least two effective dates required (cr increase)");
        QL_REQUIRE(effDates.size() == crInc.size(), "FdConvertibleBondEvents::processMakeWholeData(): effective dates ("
                                                        << effDates.size() << ") must match cr increase rows ("
                                                        << crInc.size() << ") (cr increase)");
        for (auto const& c : crInc) {
            QL_REQUIRE(c.size() == stockPrices.size(),
                       "FdConvertibleBondEvents::processMakeWholeData(): stock prices size ("
                           << stockPrices.size() << ") must match cr increase coluns (" << c.size() << ")");
        }
 
        // build interpolation
 
        mw_cr_inc_x_ = Array(stockPrices.begin(), stockPrices.end());
        mw_cr_inc_y_ = Array(effDates.size());
        mw_cr_inc_z_ = Matrix(mw_cr_inc_y_.size(), mw_cr_inc_x_.size());
 
        for (Size i = 0; i < effDates.size(); ++i) {
            mw_cr_inc_y_[i] = time(effDates[i]);
            for (Size j = 0; j < stockPrices.size(); ++j) {
                mw_cr_inc_z_(i, j) = crInc[i][j];
            }
        }
 
        auto interpolation = QuantLib::ext::make_shared<BilinearInterpolation>(
            mw_cr_inc_x_.begin(), mw_cr_inc_x_.end(), mw_cr_inc_y_.begin(), mw_cr_inc_y_.end(), mw_cr_inc_z_);
 
        // init cap (infty if not given)
 
        Real cap = QL_MAX_REAL;
        if ((*registeredMakeWholeData_.crIncreaseData).cap != Null<Real>())
            cap = (*registeredMakeWholeData_.crIncreaseData).cap;
 
        // set effetive mw cr functions on the call data
 
        for (Size i = 0; i < grid_.size(); ++i) {
            if (hasCall_[i]) {
                Real t = grid_[i];
                callData_[i].mwCr = [interpolation, t, cap](const Real S, const Real cr) {
                    if ((S < interpolation->xMin() && !close_enough(S, interpolation->xMin())) ||
                        (S > interpolation->xMax() && !close_enough(S, interpolation->xMax())) ||
                        (t < interpolation->yMin() && !close_enough(t, interpolation->yMin())) ||
                        (t > interpolation->yMax() && !close_enough(t, interpolation->yMax()))) {
                        return cr;
                    } else {
                        Real tmp = interpolation->operator()(S, t);
                        // apply cap, but if initial cr was already greater than result, keep that
                        return std::max(cr, std::min(cr + tmp, cap));
                    }
                };
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

processConversionAndDivProtData()

void processConversionAndDivProtData ( )

private

Definition at line 244 of file fdconvertiblebondevents.cpp.

                                                              {
 
    // set the initial conversion ratio
 
    std::set<std::pair<Date, Real>> crSchedule;
    for (const auto& d : registeredConversionRatioData_) {
        crSchedule.insert(std::make_pair(d.fromDate, d.conversionRatio));
    }
    if (!crSchedule.empty()) {
        initialConversionRatio_ = crSchedule.begin()->second;
    }
    std::fill(currentConversionRatio_.begin(), currentConversionRatio_.end(), initialConversionRatio_);
    additionalResults_["historicEvents.initialConversionRatio"] = initialConversionRatio_;
 
    // collect all relevant conversion events
    // - cd: cr reset event
    // - dd: dp event (with cr adjustment or pass-through)
    // - vd: voluntary conversion (with coco possibly)
    // - newCr: cr changed (or initially set to) specific value
 
    struct AdjEvent {
        ConvertibleBond2::ConversionResetData* cd = nullptr;
        ConvertibleBond2::DividendProtectionData* dd = nullptr;
        ConvertibleBond2::ConversionData* vd = nullptr;
        Real newCr = Null<Real>(); // set cr to specific value on event date
    };
 
    std::map<Date, AdjEvent> adjEvents;
 
    for (auto& d : registeredConversionResetData_) {
        adjEvents[d.resetDate].cd = &d;
    }
 
    for (auto& d : registeredDividendProtectionData_) {
        adjEvents[d.protectionDate].dd = &d;
    }
 
    for (auto& d : registeredConversionRatioData_) {
        adjEvents[d.fromDate].newCr = d.conversionRatio;
    }
 
    for (auto& d : registeredConversionData_) {
        adjEvents[d.exerciseDate].vd = &d;
    }
 
    // step through the events and process them (historical and future events)
 
    Real currentCr = initialConversionRatio_;
    Size lastDividendProtectionTimeIndex = Null<Size>();
    bool haveStochasticCr = false;
 
    for (auto const& event : adjEvents) {
 
        if (event.second.cd != nullptr) {
            const ConvertibleBond2::ConversionResetData& c = *event.second.cd;
            if (c.resetDate <= today_) {
 
                // historical conversion ratio reset event
 
                Real S = equity_->fixing(equity_->fixingCalendar().adjust(c.resetDate, Preceding));
                Real fx = 1.0;
                if (fxConversion_ != nullptr) {
                    fx = fxConversion_->fixing(JointCalendar(equity_->fixingCalendar(), fxConversion_->fixingCalendar())
                                                   .adjust(c.resetDate, Preceding));
                }
                Real cr = c.referenceType == ConvertibleBond2::ConversionResetData::ReferenceType::CurrentCP
                              ? currentCr
                              : initialConversionRatio_;
                Real referenceCP = N0_ / cr;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_S"] = S;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_threshold"] = c.threshold;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_referenceCP"] = referenceCP;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_gearing"] = c.gearing;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_floor"] = c.floor;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_globalFloor"] =
                    c.globalFloor * fx;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_fxConversion"] = fx;
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_currentCr"] = currentCr;
                if (!close_enough(cr, 0.0) && S < c.threshold * referenceCP) {
                    Real adjustedConversionRatio = QL_MAX_REAL;
                    if (!close_enough(c.gearing, 0.0)) {
                        adjustedConversionRatio = std::min(adjustedConversionRatio, N0_ / (c.gearing * S));
                    }
                    if (!close_enough(c.floor, 0.0)) {
                        adjustedConversionRatio = std::min(adjustedConversionRatio, N0_ / (c.floor * referenceCP));
                    }
                    if (!close_enough(c.globalFloor * fx, 0.0)) {
                        adjustedConversionRatio = std::min(adjustedConversionRatio, N0_ / (c.globalFloor * fx));
                    }
                    adjustedConversionRatio = std::max(
                        currentCr, adjustedConversionRatio != QL_MAX_REAL ? adjustedConversionRatio : -QL_MAX_REAL);
                    currentCr = std::max(currentCr, adjustedConversionRatio);
                }
                additionalResults_["historicEvents.crReset_" + getDateStr(event.first) + "_adjustedCr"] = currentCr;
            } else {
 
                // future conversion ratio reset event
 
                Size index = grid_.index(time(event.first));
                associatedDate_[index] = event.first;
                hasConversionReset_[index] = true;
                const ConvertibleBond2::ConversionResetData& c = *event.second.cd;
                conversionResetData_[index].resetActive = true;
                conversionResetData_[index].reference = c.referenceType;
                conversionResetData_[index].gearing = c.gearing;
                conversionResetData_[index].floor = c.floor;
                conversionResetData_[index].globalFloor = c.globalFloor * currentFxConversion_[index];
                conversionResetData_[index].threshold = c.threshold;
                for (Size i = index + 1; i < grid_.size(); ++i) {
                    stochasticConversionRatio_[i] = true;
                }
                haveStochasticCr = true;
            }
        }
 
        if (event.second.dd != nullptr) {
            const ConvertibleBond2::DividendProtectionData& c = *event.second.dd;
            if (c.protectionDate <= today_) {
                if (c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly ||
                    c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpDown ||
                    c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly2 ||
                    c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpDown2) {
 
                    // historic dividend protection event with conversion ratio adjustment
 
                    Real fx = 1.0;
                    if (fxConversion_ != nullptr) {
                        fx = fxConversion_->fixing(
                            JointCalendar(equity_->fixingCalendar(), fxConversion_->fixingCalendar())
                                .adjust(c.protectionDate, Preceding));
                    }
                    Real S = equity_->fixing(equity_->fixingCalendar().adjust(c.protectionDate, Preceding));
                    Real D = equity_->dividendsBetweenDates(c.startDate, c.protectionDate);
                    Real H = c.threshold * fx;
 
                    additionalResults_["historicEvents.crReset_DP_" + getDateStr(event.first) + "_div_" +
                                       getDateStr(c.startDate) + "_" + getDateStr(c.protectionDate)] = D;
                    additionalResults_["historicEvents.crReset_DP_" + getDateStr(event.first) + "_S"] = S;
                    additionalResults_["historicEvents.crReset_DP_" + getDateStr(event.first) + "_threshold"] = H;
                    additionalResults_["historicEvents.crReset_DP_" + getDateStr(event.first) + "_fxConversion"] = fx;
                    additionalResults_["historicEvents.crReset_DP_" + getDateStr(event.first) + "_currentCr"] =
                        currentCr;
 
                    if (c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly ||
                        c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpDown) {
                        bool absolute =
                            c.dividendType == ConvertibleBond2::DividendProtectionData::DividendType::Absolute;
                        Real d = absolute ? D : D / S;
                        Real C =
                            c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly
                                ? std::max(d - H, 0.0)
                                : d - H;
                        currentCr *= absolute ? S / std::max(S - C, 1E-4) : (1.0 + C);
                    } else {
                        Real f = std::max(S - H, 0.0) / std::max(S - D, 1E-4);
                        if (c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly2)
                            f = std::max(f, 1.0);
                        currentCr *= f;
                    }
 
                    additionalResults_["historicEvents.crReset_DP_" + getDateStr(event.first) + "_adjustedCr"] =
                        currentCr;
                }
            } else {
 
                if (c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly ||
                    c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpDown ||
                    c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpOnly2 ||
                    c.adjustmentStyle == ConvertibleBond2::DividendProtectionData::AdjustmentStyle::CrUpDown2) {
 
                    // future dividend protection event with conversion ratio adjustment
 
                    Size index = grid_.index(time(event.first));
                    associatedDate_[index] = event.first;
                    hasConversionReset_[index] = true;
                    const ConvertibleBond2::DividendProtectionData& c = *event.second.dd;
                    conversionResetData_[index].divProtActive = true;
                    conversionResetData_[index].adjustmentStyle = c.adjustmentStyle;
                    conversionResetData_[index].dividendType = c.dividendType;
                    conversionResetData_[index].divThreshold = c.threshold * currentFxConversion_[index];
                    if (lastDividendProtectionTimeIndex == Null<Size>()) {
                        conversionResetData_[index].lastDividendProtectionTimeIndex = 0;
                        conversionResetData_[index].accruedHistoricalDividends =
                            equity_->dividendsBetweenDates(c.startDate, today_);
                        additionalResults_["historicEvents.accruedDividends_" + getDateStr(c.startDate) + "_" +
                                           getDateStr(today_)] = conversionResetData_[index].accruedHistoricalDividends;
                    } else {
                        conversionResetData_[index].lastDividendProtectionTimeIndex = lastDividendProtectionTimeIndex;
                        conversionResetData_[index].accruedHistoricalDividends = 0.0;
                    }
                    lastDividendProtectionTimeIndex = index;
                    for (Size i = index + 1; i < grid_.size(); ++i) {
                        stochasticConversionRatio_[i] = true;
                    }
                    haveStochasticCr = true;
 
                } else {
 
                    // future dividend pass through event
                    Size index = grid_.index(time(c.protectionDate));
                    associatedDate_[index] = c.protectionDate;
                    hasDividendPassThrough_[index] = true;
                    dividendPassThroughData_[index].adjustmentStyle = c.adjustmentStyle;
                    dividendPassThroughData_[index].dividendType = c.dividendType;
                    dividendPassThroughData_[index].divThreshold = c.threshold;
                    if (lastDividendProtectionTimeIndex == Null<Size>()) {
                        dividendPassThroughData_[index].lastDividendProtectionTimeIndex = 0;
                        dividendPassThroughData_[index].accruedHistoricalDividends =
                            equity_->dividendsBetweenDates(c.startDate, today_);
                        additionalResults_["historicEvents.accruedDividends_" + getDateStr(c.startDate) + "_" +
                                           getDateStr(today_)] =
                            dividendPassThroughData_[index].accruedHistoricalDividends;
                    } else {
                        dividendPassThroughData_[index].lastDividendProtectionTimeIndex =
                            lastDividendProtectionTimeIndex;
                        dividendPassThroughData_[index].accruedHistoricalDividends = 0.0;
                    }
                    lastDividendProtectionTimeIndex = index;
                }
            }
        }
 
        if (event.second.vd != nullptr) {
 
            // voluntary conversion data (possibly with coco)
 
            const ConvertibleBond2::ConversionData& vd = *event.second.vd;
 
            Date nextConvDate = nextConversionDate(vd.exerciseDate);
            if (nextConvDate > today_) {
                bool conversionIsProhibited = false;
                Size indexStart = grid_.index(time(std::max(vd.exerciseDate, today_)));
                Size indexEnd;
                associatedDate_[indexStart] = std::max(vd.exerciseDate, today_);
                if (vd.exerciseType == ConvertibleBond2::ConversionData::ExerciseType::OnThisDate) {
                    indexEnd = indexStart;
                } else if (vd.exerciseType == ConvertibleBond2::ConversionData::ExerciseType::FromThisDateOn) {
                    QL_REQUIRE(nextConvDate != Null<Date>(),
                               "FdConvertibleBondEvents::processConversionData(): internal error: did not find a next "
                               "conversion "
                               "date after "
                                   << vd.exerciseDate
                                   << ", the last conversione date should not have exercise type FromThisDateOn");
                    indexEnd = grid_.index(time(nextConvDate));
                    // check whether conversion is prohibited for the future due to past coco condition check
                    if (vd.cocoType == ConvertibleBond2::ConversionData::CocoType::StartOfPeriod &&
                        vd.exerciseDate <= today_) {
                        Real S = equity_->fixing(equity_->fixingCalendar().adjust(vd.exerciseDate, Preceding));
                        conversionIsProhibited = S * currentCr <= vd.cocoBarrier;
                        additionalResults_["historicEvents.coco_" + getDateStr(vd.exerciseDate) + "_S"] = S;
                        additionalResults_["historicEvents.coco_" + getDateStr(vd.exerciseDate) + "_currentCr"] =
                            currentCr;
                        additionalResults_["historicEvents.coco_" + getDateStr(vd.exerciseDate) + "_cocoBarrier"] =
                            vd.cocoBarrier;
                        additionalResults_["historicEvents.coco_" + getDateStr(vd.exerciseDate) + "_triggered"] =
                            !conversionIsProhibited;
                    }
                } else {
                    QL_FAIL("FdConvertibleBondEvents: internal error, exercise type not recognized");
                }
                // update the grid info
                for (Size i = indexStart; i <= indexEnd; ++i) {
                    // if we have set conversion information already and the current is the last conversion
                    // date, we do not modify the exisiting information, because then the current date is the
                    // end date of the last american period.
                    if (nextConvDate == Null<Date>() && hasConversionInfoSet_[i])
                        continue;
                    // otherwise mark the index as set
                    hasConversionInfoSet_[i] = true;
                    // if the conversion is not allowed, do not set the hasConversion flag
                    if (conversionIsProhibited)
                        continue;
                    // if the conversion is allowed, set the conversion flag ...
                    hasConversion_[i] = true;
                    // ... and the conversion data
                    conversionData_[i] = ConversionData{vd.cocoBarrier};
                    // a start of period coco check should only be done, if the date is > today, otherwise it's
                    // done already
                    if (vd.cocoType == ConvertibleBond2::ConversionData::CocoType::Spot) {
                        hasContingentConversion_[i] = true;
                    } else if (vd.exerciseDate > today_ &&
                               vd.cocoType == ConvertibleBond2::ConversionData::CocoType::StartOfPeriod) {
                        hasContingentConversion_[i] = true;
                        hasNoConversionPlane_[i] = i > indexStart;
                    }
                }
            }
        }
 
        if (event.second.newCr != Null<Real>()) {
            // update current cr
            currentCr = event.second.newCr;
            if (event.first >= today_) {
                associatedDate_[grid_.index(time(event.first))] = event.first;
                if (haveStochasticCr) {
                    // we know event.first >= today if haveStochasticCr is true
                    Size index = grid_.index(time(event.first));
                    hasConversionReset_[index] = true;
                    conversionResetData_[index].resetToSpecificValue = true;
                    conversionResetData_[index].newCr = currentCr;
                }
            }
        }
 
        // update current cr on grid
 
        for (Size i = grid_.index(time(std::max(event.first, today_))); i < grid_.size(); ++i) {
            currentConversionRatio_[i] = currentCr;
        }
 
    } // for adjEvents
 
} // processConversionData()

Here is the call graph for this function:

Here is the caller graph for this function:

processMandatoryConversionData()

void processMandatoryConversionData ( )

private

Definition at line 558 of file fdconvertiblebondevents.cpp.

                                                             {
    for (auto const& d : registeredMandatoryConversionData_) {
        if (d.exerciseDate <= today_)
            continue;
        Size index = grid_.index(time(d.exerciseDate));
        associatedDate_[index] = d.exerciseDate;
        hasMandatoryConversion_[index] = true;
        mandatoryConversionData_[index] = {d.pepsUpperBarrier * currentFxConversion_[index],
                                           d.pepsLowerBarrier * currentFxConversion_[index], d.pepsUpperConversionRatio,
                                           d.pepsLowerConversionRatio};
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

today_

Date today_

private

Definition at line 165 of file fdconvertiblebondevents.hpp.

dc_

DayCounter dc_

private

Definition at line 166 of file fdconvertiblebondevents.hpp.

N0_

Real N0_

private

Definition at line 167 of file fdconvertiblebondevents.hpp.

equity_

QuantLib::ext::shared_ptr<QuantExt::EquityIndex2> equity_

private

Definition at line 168 of file fdconvertiblebondevents.hpp.

fxConversion_

QuantLib::ext::shared_ptr<FxIndex> fxConversion_

private

Definition at line 169 of file fdconvertiblebondevents.hpp.

times_

std::set<Real> times_

private

Definition at line 171 of file fdconvertiblebondevents.hpp.

grid_

TimeGrid grid_

private

Definition at line 172 of file fdconvertiblebondevents.hpp.

finalised_

bool finalised_ = false

private

Definition at line 173 of file fdconvertiblebondevents.hpp.

lastRedemptionDate_

Date lastRedemptionDate_

private

Definition at line 175 of file fdconvertiblebondevents.hpp.

registeredBondCashflows_

std::vector<QuantLib::ext::shared_ptr<CashFlow> > registeredBondCashflows_

private

Definition at line 178 of file fdconvertiblebondevents.hpp.

registeredCallData_

std::vector<ConvertibleBond2::CallabilityData> registeredCallData_

private

Definition at line 179 of file fdconvertiblebondevents.hpp.

registeredPutData_

std::vector<ConvertibleBond2::CallabilityData> registeredPutData_

private

Definition at line 179 of file fdconvertiblebondevents.hpp.

registeredConversionRatioData_

std::vector<ConvertibleBond2::ConversionRatioData> registeredConversionRatioData_

private

Definition at line 180 of file fdconvertiblebondevents.hpp.

registeredConversionData_

std::vector<ConvertibleBond2::ConversionData> registeredConversionData_

private

Definition at line 181 of file fdconvertiblebondevents.hpp.

registeredMandatoryConversionData_

std::vector<ConvertibleBond2::MandatoryConversionData> registeredMandatoryConversionData_

private

Definition at line 182 of file fdconvertiblebondevents.hpp.

registeredConversionResetData_

std::vector<ConvertibleBond2::ConversionResetData> registeredConversionResetData_

private

Definition at line 183 of file fdconvertiblebondevents.hpp.

registeredDividendProtectionData_

std::vector<ConvertibleBond2::DividendProtectionData> registeredDividendProtectionData_

private

Definition at line 184 of file fdconvertiblebondevents.hpp.

registeredMakeWholeData_

ConvertibleBond2::MakeWholeData registeredMakeWholeData_

private

Definition at line 185 of file fdconvertiblebondevents.hpp.

hasBondCashflow_

std::vector<bool> hasBondCashflow_

private

Definition at line 188 of file fdconvertiblebondevents.hpp.

hasCall_

std::vector<bool> hasCall_

private

Definition at line 188 of file fdconvertiblebondevents.hpp.

hasPut_

std::vector<bool> hasPut_

private

Definition at line 188 of file fdconvertiblebondevents.hpp.

hasConversion_

std::vector<bool> hasConversion_

private

Definition at line 189 of file fdconvertiblebondevents.hpp.

hasMandatoryConversion_

std::vector<bool> hasMandatoryConversion_

private

Definition at line 189 of file fdconvertiblebondevents.hpp.

hasContingentConversion_

std::vector<bool> hasContingentConversion_

private

Definition at line 189 of file fdconvertiblebondevents.hpp.

hasConversionInfoSet_

std::vector<bool> hasConversionInfoSet_

private

Definition at line 189 of file fdconvertiblebondevents.hpp.

hasNoConversionPlane_

std::vector<bool> hasNoConversionPlane_

private

Definition at line 190 of file fdconvertiblebondevents.hpp.

hasConversionReset_

std::vector<bool> hasConversionReset_

private

Definition at line 190 of file fdconvertiblebondevents.hpp.

hasDividendPassThrough_

std::vector<bool> hasDividendPassThrough_

private

Definition at line 191 of file fdconvertiblebondevents.hpp.

bondCashflow_

std::vector<Real> bondCashflow_

private

Definition at line 194 of file fdconvertiblebondevents.hpp.

bondFinalRedemption_

std::vector<Real> bondFinalRedemption_

private

Definition at line 194 of file fdconvertiblebondevents.hpp.

callData_

std::vector<CallData> callData_

private

Definition at line 195 of file fdconvertiblebondevents.hpp.

putData_

std::vector<CallData> putData_

private

Definition at line 195 of file fdconvertiblebondevents.hpp.

conversionData_

std::vector<ConversionData> conversionData_

private

Definition at line 196 of file fdconvertiblebondevents.hpp.

mandatoryConversionData_

std::vector<MandatoryConversionData> mandatoryConversionData_

private

Definition at line 197 of file fdconvertiblebondevents.hpp.

conversionResetData_

std::vector<ConversionResetData> conversionResetData_

private

Definition at line 198 of file fdconvertiblebondevents.hpp.

dividendPassThroughData_

std::vector<DividendPassThroughData> dividendPassThroughData_

private

Definition at line 199 of file fdconvertiblebondevents.hpp.

stochasticConversionRatio_

std::vector<bool> stochasticConversionRatio_

private

Definition at line 201 of file fdconvertiblebondevents.hpp.

initialConversionRatio_

Real initialConversionRatio_

private

Definition at line 202 of file fdconvertiblebondevents.hpp.

currentConversionRatio_

std::vector<Real> currentConversionRatio_

private

Definition at line 203 of file fdconvertiblebondevents.hpp.

currentFxConversion_

std::vector<Real> currentFxConversion_

private

Definition at line 204 of file fdconvertiblebondevents.hpp.

associatedDate_

std::vector<Date> associatedDate_

private

Definition at line 205 of file fdconvertiblebondevents.hpp.

additionalResults_

std::map<std::string, boost::any> additionalResults_

private

Definition at line 208 of file fdconvertiblebondevents.hpp.

mw_cr_inc_x_

QuantLib::Array mw_cr_inc_x_

private

Definition at line 211 of file fdconvertiblebondevents.hpp.

mw_cr_inc_y_

QuantLib::Array mw_cr_inc_y_

private

Definition at line 211 of file fdconvertiblebondevents.hpp.

mw_cr_inc_z_

QuantLib::Matrix mw_cr_inc_z_

private

Definition at line 212 of file fdconvertiblebondevents.hpp.