#include <qle/methods/fdmdefaultableequityjumpdiffusionop.hpp>

Inheritance diagram for FdmDefaultableEquityJumpDiffusionOp:

Collaboration diagram for FdmDefaultableEquityJumpDiffusionOp:

Public Member Functions
	FdmDefaultableEquityJumpDiffusionOp (const QuantLib::ext::shared_ptr< QuantLib::FdmMesher > &mesher, const QuantLib::ext::shared_ptr< DefaultableEquityJumpDiffusionModel > &model, const Size direction=0, const std::function< Real(Real, Real, Real)> &recovery={}, const Handle< QuantLib::YieldTermStructure > &discountingCurve=Handle< QuantLib::YieldTermStructure >(), const Handle< QuantLib::Quote > &discountingSpread=Handle< QuantLib::Quote >(), const Handle< QuantLib::DefaultProbabilityTermStructure > &addCreditCurve=Handle< QuantLib::DefaultProbabilityTermStructure >(), const std::function< Real(Real, Real, Real)> &addRecovery={})

Size	size () const override

void	setTime (Time t1, Time t2) override

Array	apply (const Array &r) const override

Array	apply_mixed (const Array &r) const override

Array	apply_direction (Size direction, const Array &r) const override

Array	solve_splitting (Size direction, const Array &r, Real s) const override

Array	preconditioner (const Array &r, Real s) const override

std::vector< QuantLib::SparseMatrix >	toMatrixDecomp () const override

void	setConversionRatio (const std::function< Real(Real)> &conversionRatio)

Private Attributes
QuantLib::ext::shared_ptr< QuantLib::FdmMesher >	mesher_

QuantLib::ext::shared_ptr< DefaultableEquityJumpDiffusionModel >	model_

Size	direction_

std::function< Real(Real, Real, Real)>	recovery_

Handle< QuantLib::YieldTermStructure >	discountingCurve_

Handle< QuantLib::DefaultProbabilityTermStructure >	addCreditCurve_

std::function< Real(Real, Real, Real)>	addRecovery_

Handle< QuantLib::Quote >	discountingSpread_

QuantLib::FirstDerivativeOp	dxMap_

QuantLib::TripleBandLinearOp	dxxMap_

QuantLib::TripleBandLinearOp	mapT_

Array	recoveryTerm_

std::function< Real(Real)>	conversionRatio_

Detailed Description

Definition at line 34 of file fdmdefaultableequityjumpdiffusionop.hpp.

Constructor & Destructor Documentation

◆ FdmDefaultableEquityJumpDiffusionOp()

FdmDefaultableEquityJumpDiffusionOp	(	const QuantLib::ext::shared_ptr< QuantLib::FdmMesher > &	mesher,
		const QuantLib::ext::shared_ptr< DefaultableEquityJumpDiffusionModel > &	model,
		const Size	direction = `0`,
		const std::function< Real(Real, Real, Real)> &	recovery = `{}`,
		const Handle< QuantLib::YieldTermStructure > &	discountingCurve = `Handle<QuantLib::YieldTermStructure>()`,
		const Handle< QuantLib::Quote > &	discountingSpread = `Handle<QuantLib::Quote>()`,
		const Handle< QuantLib::DefaultProbabilityTermStructure > &	addCreditCurve = `Handle<QuantLib::DefaultProbabilityTermStructure>()`,
		const std::function< Real(Real, Real, Real)> &	addRecovery = `{}`
	)

The recovery is given as a function of (t, S, conversionRatio)
The model rate r can be overwritten with a discountingCurve, this is used in the discounting term of the operator then, but not the drift term. This can e.g. be bond discounting curve in convertible bond pricings.
An additional credit curve and associated recovery rate function can be specified, which will constitute an additional discounting term and recovery term. This can e.g. be the bond credit curve for exchangeable convertible bonds (in this context, the model credit curve will be the equity credit curve then).

Definition at line 27 of file fdmdefaultableequityjumpdiffusionop.cpp.

    : mesher_(mesher), model_(model), direction_(direction), recovery_(recovery), discountingCurve_(discountingCurve),
      addCreditCurve_(addCreditCurve), addRecovery_(addRecovery), discountingSpread_(discountingSpread),
      dxMap_(FirstDerivativeOp(direction, mesher)), dxxMap_(SecondDerivativeOp(direction, mesher)),
      mapT_(direction, mesher), recoveryTerm_(mesher_->locations(direction).size()) {}

Member Function Documentation

◆ size()

Size size ( ) const

override

Definition at line 39 of file fdmdefaultableequityjumpdiffusionop.cpp.

39{ return 1ul; }

◆ setTime()

void setTime	(	Time	t1,
		Time	t2
	)

override

Definition at line 41 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                  {
 
    Size n = mesher_->locations(direction_).size();
 
    Real r = model_->r(t1);
    Real q = model_->q(t1);
    Real v = model_->sigma(t1) * model_->sigma(t1);
 
    Array h(n);
    for (Size i = 0; i < h.size(); ++i) {
        h[i] = model_->h(t1, std::exp(mesher_->locations(direction_)[i]));
    }
 
    // overwrite discounting term with external curve and / or add external spread
 
    Real r_dis = r;
    if (!discountingCurve_.empty()) {
        r_dis = discountingCurve_->forwardRate(t1, t2, Continuous);
    }
    if (!discountingSpread_.empty()) {
        r_dis += discountingSpread_->value();
    }
 
    // additional credit discounting term
 
    Array h2(n, 0.0);
    if (!addCreditCurve_.empty()) {
        QL_REQUIRE(!close_enough(addCreditCurve_->survivalProbability(t1), 0.0),
                   "FdmDefaultableEquityJumpDiffusionOp: addCreditCurve implies zero survival probability at t = "
                       << t1
                       << ", this can not be handled. Check the credit curve / security spread provided in the market "
                          "data. If this happens during a spread imply, the target price might not be ataainable even "
                          "for high spreads.");
        Real tmp =
            -std::log(addCreditCurve_->survivalProbability(t2) / addCreditCurve_->survivalProbability(t1)) / (t2 - t1);
        std::fill(h2.begin(), h2.end(), tmp);
    }
 
    Array drift(n, r - q - 0.5 * v);
    if (model_->adjustEquityForward())
        drift += model_->eta() * h;
    mapT_.axpyb(drift, dxMap_, dxxMap_.mult(Array(n, 0.5 * v)), -(Array(n, r_dis) + h + h2));
 
    for (Size i = 0; i < n; ++i) {
        Real S = std::exp(mesher_->locations(direction_)[i]);
        Real cr = conversionRatio_ ? conversionRatio_(S) : Null<Real>();
        recoveryTerm_[i] = 0.0;
        if (recovery_) {
            recoveryTerm_[i] += recovery_(t1, S, cr) * h[i];
        }
        if (addRecovery_) {
            recoveryTerm_[i] += addRecovery_(t1, S, cr) * h2[i];
        }
    }
}

Here is the call graph for this function:

◆ apply()

Array apply ( const Array & r ) const

override

Definition at line 97 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                     {
    return mapT_.apply(r) + recoveryTerm_;
}

◆ apply_mixed()

Array apply_mixed ( const Array & r ) const

override

Definition at line 101 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                           {
    Array retVal(r.size(), 0.0);
    return retVal;
}

◆ apply_direction()

Array apply_direction	(	Size	direction,
		const Array &	r
	)		const

override

Definition at line 106 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                                               {
    if (direction == direction_)
        return mapT_.apply(r);
    else {
        Array retVal(r.size(), 0.0);
        return retVal;
    }
}

◆ solve_splitting()

Array solve_splitting	(	Size	direction,
		const Array &	r,
		Real	s
	)		const

override

Definition at line 115 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                                                       {
    if (direction == direction_) {
        return mapT_.solve_splitting(r, s, 1.0);
    } else {
        Array retVal(r);
        return retVal;
    }
}

Here is the caller graph for this function:

◆ preconditioner()

Array preconditioner	(	const Array &	r,
		Real	s
	)		const

override

Definition at line 124 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                                      {
    return solve_splitting(direction_, r, s);
}

Here is the call graph for this function:

◆ toMatrixDecomp()

std::vector< QuantLib::SparseMatrix > toMatrixDecomp ( ) const

override

Definition at line 129 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                                          {
    std::vector<SparseMatrix> retVal(1, mapT_.toMatrix());
    return retVal;
}

◆ setConversionRatio()

void setConversionRatio ( const std::function< Real(Real)> & conversionRatio )

Definition at line 135 of file fdmdefaultableequityjumpdiffusionop.cpp.

                                                                                                           {
    conversionRatio_ = conversionRatio;
}