#include <qle/models/defaultableequityjumpdiffusionmodel.hpp>

Inheritance diagram for DefaultableEquityJumpDiffusionModelBuilder:

Collaboration diagram for DefaultableEquityJumpDiffusionModelBuilder:

Public Types
enum class	BootstrapMode { Alternating , Simultaneously }

Public Member Functions
	DefaultableEquityJumpDiffusionModelBuilder (const std::vector< Real > &stepTimes, const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &equity, const Handle< QuantLib::BlackVolTermStructure > &volatility, const Handle< QuantLib::DefaultProbabilityTermStructure > &creditCurve, const Real p=0.0, const Real eta=1.0, const bool staticMesher=false, const Size timeStepsPerYear=24, const Size stateGridPoints=100, const Real mesherEpsilon=1E-4, const Real mesherScaling=1.5, const Real mesherConcentration=Null< Real >(), const BootstrapMode mode=BootstrapMode::Alternating, const bool enforceFokkerPlanckBootstrap=false, const bool calibrate=true, const bool adjustEquityVolatility=true, const bool adjustEquityForward=true)

Handle< DefaultableEquityJumpDiffusionModel >	model () const

Public Member Functions inherited from ModelBuilder
void	recalibrate () const
	recalibrate model, if necessary More...

virtual void	forceRecalculate ()
	force recalibration of model More...

virtual bool	requiresRecalibration () const =0
	if false is returned, the model does not require a recalibration More...

ModelBuilder interface
std::vector< Real >	stepTimes_

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

Handle< BlackVolTermStructure >	volatility_

Handle< DefaultProbabilityTermStructure >	creditCurve_

Real	p_

Real	eta_

bool	staticMesher_

Size	timeStepsPerYear_

Size	stateGridPoints_

Real	mesherEpsilon_

Real	mesherScaling_

Real	mesherConcentration_

BootstrapMode	bootstrapMode_

bool	enforceFokkerPlanckBootstrap_

bool	calibrate_

bool	adjustEquityVolatility_

bool	adjustEquityForward_

bool	forceCalibration_ = false

QuantLib::ext::shared_ptr< MarketObserver >	marketObserver_

std::vector< Real >	cachedForwards_

std::vector< Real >	cachedVariances_

RelinkableHandle< DefaultableEquityJumpDiffusionModel >	model_

void	forceRecalculate () override
	force recalibration of model More...

bool	requiresRecalibration () const override
	if false is returned, the model does not require a recalibration More...

void	performCalculations () const override

bool	calibrationPointsChanged (const bool updateCache) const

Detailed Description

Definition at line 43 of file defaultableequityjumpdiffusionmodel.hpp.

Member Enumeration Documentation

◆ BootstrapMode

enum class BootstrapMode

strong

Enumerator
Alternating
Simultaneously

Definition at line 45 of file defaultableequityjumpdiffusionmodel.hpp.

45{ Alternating, Simultaneously };

QuantExt::DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode::Simultaneously

@ Simultaneously

QuantExt::DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode::Alternating

@ Alternating

Constructor & Destructor Documentation

◆ DefaultableEquityJumpDiffusionModelBuilder()

DefaultableEquityJumpDiffusionModelBuilder	(	const std::vector< Real > &	stepTimes,
		const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &	equity,
		const Handle< QuantLib::BlackVolTermStructure > &	volatility,
		const Handle< QuantLib::DefaultProbabilityTermStructure > &	creditCurve,
		const Real	p = `0.0`,
		const Real	eta = `1.0`,
		const bool	staticMesher = `false`,
		const Size	timeStepsPerYear = `24`,
		const Size	stateGridPoints = `100`,
		const Real	mesherEpsilon = `1E-4`,
		const Real	mesherScaling = `1.5`,
		const Real	mesherConcentration = `Null<Real>()`,
		const BootstrapMode	mode = `BootstrapMode::Alternating`,
		const bool	enforceFokkerPlanckBootstrap = `false`,
		const bool	calibrate = `true`,
		const bool	adjustEquityVolatility = `true`,
		const bool	adjustEquityForward = `true`
	)

Definition at line 37 of file defaultableequityjumpdiffusionmodel.cpp.

    : stepTimes_(stepTimes), equity_(equity), volatility_(volatility), creditCurve_(creditCurve), p_(p), eta_(eta),
      staticMesher_(staticMesher), timeStepsPerYear_(timeStepsPerYear), stateGridPoints_(stateGridPoints),
      mesherEpsilon_(mesherEpsilon), mesherScaling_(mesherScaling), mesherConcentration_(mesherConcentration),
      bootstrapMode_(bootstrapMode), enforceFokkerPlanckBootstrap_(enforceFokkerPlanckBootstrap), calibrate_(calibrate),
      adjustEquityVolatility_(adjustEquityVolatility), adjustEquityForward_(adjustEquityForward) {
 
    // checks
 
    QL_REQUIRE(!stepTimes.empty(), "DefaultableEquityJumpDiffusionModel: at least one step time required");
    QL_REQUIRE(close_enough(p_, 0.0) || adjustEquityVolatility_,
               "DefaultableEquityJumpDiffusionModel: for p != 0 (" << p_ << ") adjustEquityVolatility must be true");
 
    // register with observables
 
    marketObserver_ = QuantLib::ext::make_shared<MarketObserver>();
    marketObserver_->registerWith(equity_);
    marketObserver_->registerWith(creditCurve_);
 
    registerWith(volatility_);
    registerWith(marketObserver_);
 
    // notify observers of all market data changes, not only when not calculated
    alwaysForwardNotifications();
}

Here is the call graph for this function:

Member Function Documentation

◆ model()

Handle< DefaultableEquityJumpDiffusionModel > model ( ) const

Definition at line 69 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                                                    {
    calculate();
    return model_;
}

◆ forceRecalculate()

void forceRecalculate ( )

overridevirtual

force recalibration of model

Reimplemented from ModelBuilder.

Definition at line 74 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                  {
    forceCalibration_ = true;
    ModelBuilder::forceRecalculate();
    forceCalibration_ = false;
}

Here is the call graph for this function:

◆ requiresRecalibration()

bool requiresRecalibration ( ) const

overridevirtual

if false is returned, the model does not require a recalibration

Implements ModelBuilder.

Definition at line 80 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                             {
    return calibrationPointsChanged(false) || marketObserver_->hasUpdated(false) || forceCalibration_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 123 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                           {
 
    if (requiresRecalibration()) {
 
        calibrationPointsChanged(true);
 
        // reset market observer's updated flag
 
        marketObserver_->hasUpdated(true);
 
        // setup model and bootstrap the model parameters
 
        std::vector<Real> h0(stepTimes_.size(), 0.0);
        std::vector<Real> sigma(stepTimes_.size(), 0.10);
        model_.linkTo(QuantLib::ext::make_shared<DefaultableEquityJumpDiffusionModel>(
            stepTimes_, h0, sigma, equity_, creditCurve_, volatility_->dayCounter(), p_, eta_, adjustEquityForward_));
        if (calibrate_) {
            model_->bootstrap(volatility_, staticMesher_, timeStepsPerYear_, stateGridPoints_, mesherEpsilon_,
                              mesherScaling_, mesherConcentration_, bootstrapMode_, enforceFokkerPlanckBootstrap_,
                              adjustEquityVolatility_);
        }
 
        // notify model observers
        model_->notifyObservers();
    }
}

Here is the call graph for this function:

◆ calibrationPointsChanged()

bool calibrationPointsChanged ( const bool updateCache ) const

private

Definition at line 84 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                                                      {
 
    // get the current foewards and vols
 
    std::vector<Real> forwards;
    std::vector<Real> variances;
    for (auto const t : stepTimes_) {
        forwards.push_back(equity_->equitySpot()->value() * equity_->equityDividendCurve()->discount(t) /
                           equity_->equityForecastCurve()->discount(t));
        variances.push_back(volatility_->blackVariance(t, forwards.back()));
    }
 
    // check for differences
 
    bool changed = false;
    if (stepTimes_.size() != cachedForwards_.size() || stepTimes_.size() != cachedVariances_.size()) {
        changed = true;
    } else {
        for (Size i = 0; i < stepTimes_.size() && !changed; ++i) {
            // strict comparison is deliberate here!
            if (cachedForwards_[i] != forwards[i])
                changed = true;
            else if (cachedVariances_[i] != variances[i])
                changed = true;
        }
    }
 
    // update cache if caller desires so
 
    if (updateCache) {
        cachedForwards_ = forwards;
        cachedVariances_ = variances;
    }
 
    // return the result
 
    return changed;
}