DefaultableEquityJumpDiffusionModel Class Reference

#include <qle/models/defaultableequityjumpdiffusionmodel.hpp>

Inheritance diagram for DefaultableEquityJumpDiffusionModel:

Collaboration diagram for DefaultableEquityJumpDiffusionModel:

Public Member Functions
	DefaultableEquityJumpDiffusionModel (const std::vector< Real > &stepTimes, const std::vector< Real > &h0, const std::vector< Real > &sigma, const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &equity, const Handle< QuantLib::DefaultProbabilityTermStructure > &creditCurve, const DayCounter &volDayCounter, const Real p=0.0, const Real eta=1.0, const bool adjustEquityForward=true)
const std::vector< Real > &	stepTimes () const
QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 >	equity () const
Real	totalBlackVariance () const
const DayCounter &	volDayCounter () const
Handle< QuantLib::DefaultProbabilityTermStructure >	creditCurve () const
Real	eta () const
Real	p () const
bool	adjustEquityForward () const
Real	timeFromReference (const Date &d) const
const std::vector< Real > &	h0 () const
const std::vector< Real > &	sigma () const
Real	h (const Real t, const Real S) const
Real	h0 (const Real t) const
Real	r (const Real t) const
Real	q (const Real t) const
Real	sigma (const Real t) const
Real	dividendYield (const Real s, const Real t) const
void	bootstrap (const Handle< QuantLib::BlackVolTermStructure > &volatility, const bool staticMesher, const Size timeStepsPerYear, const Size stateGridPoints=100, const Real mesherEpsilon=1E-4, const Real mesherScaling=1.5, const Real mesherConcentration=Null< Real >(), const DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode bootstrapMode=DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode::Alternating, const bool enforceFokkerPlanckBootstrap=false, const bool adjustEquityVolatility=true) const
void	update () override

Private Member Functions
QuantLib::Size	getTimeIndex (const Real t) const

Private Attributes
std::vector< Real >	stepTimes_
std::vector< Real >	h0_
std::vector< Real >	sigma_
QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 >	equity_
Handle< DefaultProbabilityTermStructure >	creditCurve_
DayCounter	volDayCounter_
Real	p_
Real	eta_
bool	adjustEquityForward_
QuantLib::ext::shared_ptr< Fdm1dMesher >	mesher_
Real	totalBlackVariance_ = 1.0

Static Private Attributes
static constexpr Real	fh_ = 1E-4

Detailed Description

Definition at line 95 of file defaultableequityjumpdiffusionmodel.hpp.

Constructor & Destructor Documentation

DefaultableEquityJumpDiffusionModel()

DefaultableEquityJumpDiffusionModel	(	const std::vector< Real > &	stepTimes,
		const std::vector< Real > &	h0,
		const std::vector< Real > &	sigma,
		const QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > &	equity,
		const Handle< QuantLib::DefaultProbabilityTermStructure > &	creditCurve,
		const DayCounter &	volDayCounter,
		const Real	p = 0.0,
		const Real	eta = 1.0,
		const bool	adjustEquityForward = true
	)

Definition at line 150 of file defaultableequityjumpdiffusionmodel.cpp.

    : stepTimes_(stepTimes), h0_(h0), sigma_(sigma), equity_(equity), creditCurve_(creditCurve),
      volDayCounter_(volDayCounter), p_(p), eta_(eta), adjustEquityForward_(adjustEquityForward) {
    registerWith(equity);
    registerWith(creditCurve);
}

Here is the call graph for this function:

Member Function Documentation

stepTimes()

const std::vector< Real > & stepTimes

(

)

const

Definition at line 163 of file defaultableequityjumpdiffusionmodel.cpp.

{ return stepTimes_; }

equity()

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

(

)

const

Definition at line 165 of file defaultableequityjumpdiffusionmodel.cpp.

{ return equity_; }

Here is the caller graph for this function:

totalBlackVariance()

Real totalBlackVariance

(

)

const

Definition at line 167 of file defaultableequityjumpdiffusionmodel.cpp.

{ return totalBlackVariance_; }

volDayCounter()

const DayCounter & volDayCounter

(

)

const

Definition at line 169 of file defaultableequityjumpdiffusionmodel.cpp.

{ return volDayCounter_; }

creditCurve()

Handle< DefaultProbabilityTermStructure > creditCurve

(

)

const

Definition at line 171 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                                               {
    return creditCurve_;
}

Here is the caller graph for this function:

eta()

Real eta

(

)

const

Definition at line 175 of file defaultableequityjumpdiffusionmodel.cpp.

{ return eta_; }

Here is the caller graph for this function:

p()

Real p

(

)

const

Definition at line 177 of file defaultableequityjumpdiffusionmodel.cpp.

{ return p_; }

Here is the caller graph for this function:

adjustEquityForward()

bool adjustEquityForward

(

)

const

Definition at line 179 of file defaultableequityjumpdiffusionmodel.cpp.

{ return adjustEquityForward_; }

timeFromReference()

Real timeFromReference

(

const Date &

d

)

const

Definition at line 181 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                               {
    return volDayCounter_.yearFraction(creditCurve_->referenceDate(), d);
}

h0() [1/2]

const std::vector< Real > & h0

(

)

const

Definition at line 185 of file defaultableequityjumpdiffusionmodel.cpp.

{ return h0_; }

sigma() [1/2]

const std::vector< Real > & sigma

(

)

const

Definition at line 187 of file defaultableequityjumpdiffusionmodel.cpp.

{ return sigma_; }

h()

Real h	(	const Real	t,
		const Real	S
	)		const

Definition at line 196 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                            {
    return h0_[getTimeIndex(t)] * std::pow(equity_->equitySpot()->value() / S, p_);
}

Here is the call graph for this function:

h0() [2/2]

Real h0

(

const Real

t

)

const

r()

Real r

(

const Real

t

)

const

Definition at line 202 of file defaultableequityjumpdiffusionmodel.cpp.

                                                              {
    if (t > fh_) {
        return -std::log(equity_->equityForecastCurve()->discount(t + fh_) /
                         equity_->equityForecastCurve()->discount(t - fh_)) /
               (2.0 * fh_);
    } else {
        return -std::log(equity_->equityForecastCurve()->discount(t + fh_) /
                         equity_->equityForecastCurve()->discount(t)) /
               (fh_);
    }
}

q()

Real q

(

const Real

t

)

const

Definition at line 214 of file defaultableequityjumpdiffusionmodel.cpp.

                                                              {
    if (t > fh_) {
        return -std::log(equity_->equityDividendCurve()->discount(t + fh_) /
                         equity_->equityDividendCurve()->discount(t - fh_)) /
               (2.0 * fh_);
    } else {
        return -std::log(equity_->equityDividendCurve()->discount(t + fh_) /
                         equity_->equityDividendCurve()->discount(t)) /
               (fh_);
    }
}

sigma() [2/2]

Real sigma

(

const Real

t

)

const

Definition at line 200 of file defaultableequityjumpdiffusionmodel.cpp.

{ return sigma_[getTimeIndex(t)]; }

Here is the call graph for this function:

dividendYield()

Real dividendYield	(	const Real	s,
		const Real	t
	)		const

Definition at line 226 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                                        {
    QL_REQUIRE(t > s || close_enough(s, t), "DefaultableEquityJumppDiffusionModel::dividendYield(): start time ("
                                                << s << ") must be less or equal than end time (" << t << ")");
    Real tmp = t;
    if (close_enough(s, t)) {
        tmp = s + fh_;
    }
    return -std::log(equity_->equityDividendCurve()->discount(tmp) / equity_->equityDividendCurve()->discount(s)) /
           (tmp - s);
}

Here is the call graph for this function:

bootstrap()

void bootstrap	(	const Handle< QuantLib::BlackVolTermStructure > &	volatility,
		const bool	staticMesher,
		const Size	timeStepsPerYear,
		const Size	stateGridPoints = 100,
		const Real	mesherEpsilon = 1E-4,
		const Real	mesherScaling = 1.5,
		const Real	mesherConcentration = Null<Real>(),
		const DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode	bootstrapMode = DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode::Alternating,
		const bool	enforceFokkerPlanckBootstrap = false,
		const bool	adjustEquityVolatility = true
	)		const

Definition at line 237 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                                      {
 
    // set total black variance
 
    Real forward = equity_->equitySpot()->value() * equity_->equityDividendCurve()->discount(stepTimes_.back()) /
                   equity_->equityForecastCurve()->discount(stepTimes_.back());
    totalBlackVariance_ = volatility->blackVariance(stepTimes_.back(), forward);
 
    // check validity of credit curve, otherwise we might divide by zero below
 
    for (Size i = 0; i < stepTimes_.size(); ++i) {
        QL_REQUIRE(!close_enough(creditCurve_->survivalProbability(stepTimes_[i]), 0.0),
                   "DefaultableEquityJumpDiffusionModel: creditCurve implies zero survival probability at t = "
                       << stepTimes_[i]
                       << ", 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 attainable even "
                          "for high spreads.");
    }
 
    if (close_enough(p_, 0.0) && !enforceFokkerPlanckBootstrap) {
 
        // 1. case p = 0:
 
        Real accumulatedVariance = 0.0;
 
        for (Size i = 0; i < stepTimes_.size(); ++i) {
 
            // 1.1 the stepwise model h is just the average hazard rate over each interval
 
            h0_[i] = -std::log(creditCurve_->survivalProbability(stepTimes_[i]) /
                               (i == 0 ? 1.0 : creditCurve_->survivalProbability(stepTimes_[i - 1]))) /
                     (stepTimes_[i] - (i == 0 ? 0.0 : stepTimes_[i - 1]));
 
            // 1.2 determine the implied equity vol in our model
 
            Real impliedModelVol = 0.0;
            Real forward = equity_->equitySpot()->value() / equity_->equityForecastCurve()->discount(stepTimes_[i]) *
                           equity_->equityDividendCurve()->discount(stepTimes_[i]);
 
            if (!adjustEquityVolatility) {
 
                // 1.2.1 if we do not adjust the equity vol, we just read it from the market surface
 
                impliedModelVol = volatility->blackVol(stepTimes_[i], forward);
 
            } else {
 
                // 1.2.2 if we adjust the equity vol, we first compute the market atm option price
 
                Real marketPrice = blackFormula(Option::Call, forward, forward,
                                                std::sqrt(volatility->blackVariance(stepTimes_[i], forward)),
                                                equity_->equityForecastCurve()->discount(stepTimes_[i]));
 
                // 1.2.2 adjust the forward and the discount factor by the credit drift / jump intensity and back out
                // the model implied vol using these and the market price computed above
 
                // TODO a tacit assumption here is that a defaulted equity does not contribute signficantly to the ATM
                // call option payoff, i.e. that eta is sufficiently close to 1, review this and compare to the "full"
                // implementation via Fokker-Planck below
 
                Real adjustedForward = adjustEquityForward_
                                           ? forward / std::pow(creditCurve_->survivalProbability(stepTimes_[i]), eta_)
                                           : forward;
                try {
                    impliedModelVol =
                        blackFormulaImpliedStdDev(Option::Call, forward, adjustedForward, marketPrice,
                                                  equity_->equityForecastCurve()->discount(stepTimes_[i]) *
                                                      creditCurve_->survivalProbability(stepTimes_[i])) /
                        std::sqrt(stepTimes_[i]);
                } catch (...) {
                }
            }
 
            impliedModelVol = std::max(1E-4, impliedModelVol);
 
            // 1.3 bootstrap the stepwise model sigma
 
            sigma_[i] =
                i == 0
                    ? impliedModelVol
                    : std::sqrt(std::max(impliedModelVol * impliedModelVol * stepTimes_[i] - accumulatedVariance, 0.0) /
                                (stepTimes_[i] - stepTimes_[i - 1]));
 
            accumulatedVariance += sigma_[i] * sigma_[i] * (stepTimes_[i] - (i == 0 ? 0.0 : stepTimes_[i - 1]));
        }
 
    } else {
 
        // 2. case p != 0 (or enforced Fokker-Planck method for bootstrap)
 
        // 2.1 set up solver for the Fokker-Planck PDE
 
        // 2.1.1 build mesher
 
        Real spot = equity()->equitySpot()->value();
        Real logSpot = std::log(spot);
 
        if (mesher_ == nullptr || !staticMesher) {
 
            TimeGrid tmpGrid(stepTimes_.begin(), stepTimes_.end(),
                             std::max<Size>(std::lround(timeStepsPerYear * stepTimes_.back() + 0.5), 1));
 
            Real mi = spot;
            Real ma = spot;
 
            Real forward = spot;
            for (Size i = 1; i < tmpGrid.size(); ++i) {
                forward = equity()->equitySpot()->value() * equity()->equityDividendCurve()->discount(tmpGrid[i]) /
                          equity()->equityForecastCurve()->discount(tmpGrid[i]) /
                          std::pow(creditCurve()->survivalProbability(tmpGrid[i]), eta());
                mi = std::min(mi, forward);
                ma = std::max(ma, forward);
            }
 
            Real sigmaSqrtT = std::max(1E-4, std::sqrt(volatility->blackVariance(tmpGrid.back(), forward)));
            Real normInvEps = InverseCumulativeNormal()(1.0 - mesherEpsilon);
            Real xMin = std::log(mi) - sigmaSqrtT * normInvEps * mesherScaling;
            Real xMax = std::log(ma) + sigmaSqrtT * normInvEps * mesherScaling;
 
            if (mesherConcentration != Null<Real>()) {
                mesher_ = QuantLib::ext::make_shared<Concentrating1dMesher>(xMin, xMax, stateGridPoints,
                                                                    std::make_pair(logSpot, mesherConcentration), true);
            } else {
                mesher_ = QuantLib::ext::make_shared<Uniform1dMesher>(xMin, xMax, stateGridPoints);
            }
        }
 
        // 2.1.2 build operator
 
        auto fdmOp = QuantLib::ext::make_shared<FdmDefaultableEquityJumpDiffusionFokkerPlanckOp>(
            stepTimes_.back(), QuantLib::ext::make_shared<FdmMesherComposite>(mesher_), shared_from_this());
 
        // 2.1.3 build solver
 
        // TODO which schema / how many damping steps should we take? For the moment we follow the recommendation from
        // the Andersen paper and use Crank-Nicholson after a "few" Rannacher steps (i.e. implicit Euler)
        // TrBDF2 seems to be a specialised scheme for initial Dirac conditons though. Some research required...
 
        auto solver = QuantLib::ext::make_shared<FdmBackwardSolver>(
            fdmOp, std::vector<QuantLib::ext::shared_ptr<BoundaryCondition<FdmLinearOp>>>(), nullptr, FdmSchemeDesc::Douglas());
 
        constexpr Size dampingSteps = 5;
 
        // 2.2 boostrap h0 and sigma functions
 
        // 2.2.1 set integration length dy for each grid point (= center of integration interval) and initial condition
 
        Array p(mesher_->size(), 0.0), dy(mesher_->size(), 0.0);
 
        for (Size i = 0; i < mesher_->size(); ++i) {
            if (i > 0) {
                dy[i] += 0.5 * mesher_->dminus(i);
            } else {
                dy[i] += 0.5 * mesher_->dminus(i + 1);
            }
            if (i < mesher_->size() - 1) {
                dy[i] += 0.5 * mesher_->dplus(i);
            } else {
                dy[i] += 0.5 * mesher_->dplus(i - 1);
            }
        }
 
        for (Size i = 0; i < mesher_->size(); ++i) {
            if (i > 0) {
                if ((logSpot > mesher_->location(i - 1) || close_enough(logSpot, mesher_->location(i - 1))) &&
                    (logSpot < mesher_->location(i) && !close_enough(logSpot, mesher_->location(i)))) {
                    Real alpha = (mesher_->location(i) - logSpot) / mesher_->dplus(i - 1);
                    p[i - 1] = alpha / dy[i - 1];
                    p[i] = (1 - alpha) / dy[i];
                }
            }
        }
 
        Array guess(2);
 
        // bookkeeping to maange optimization guesses (see below)
        constexpr Real thresholdSuccessfulOptimization = 1E-5;
        Real lastOptimizationError = 0.0;
        Array lastValidGuess;
 
        for (Size i = 0; i < stepTimes_.size(); ++i) {
 
            // 2.2.2 we roll from timestep i-1 (t=0 for i=0) to i and calibrate (h0, sigma) to the market
 
            Real marketDefaultableBond = creditCurve_->survivalProbability(stepTimes_[i]) *
                                         equity_->equityForecastCurve()->discount(stepTimes_[i]);
            Real forward = equity_->equitySpot()->value() / equity_->equityForecastCurve()->discount(stepTimes_[i]) *
                           equity_->equityDividendCurve()->discount(stepTimes_[i]);
            Real marketEquityOption = blackFormula(Option::Call, forward, forward,
                                                   std::sqrt(volatility->blackVariance(stepTimes_[i], forward)),
                                                   equity_->equityForecastCurve()->discount(stepTimes_[i]));
 
            struct TargetFunction : public QuantLib::CostFunction {
                static Real hToOpt(const Real x) { return std::log(std::max(x, 1E-6)); }
                static Real sigmaToOpt(const Real x) { return std::log(std::max(x, 1E-6)); }
                static Real hToReal(const Real x) { return std::exp(x); }
                static Real sigmaToReal(const Real x) { return std::exp(x); }
 
                enum class Mode { h0, sigma, both };
                TargetFunction(const Mode mode, const Real strike, const Real marketEquityOption,
                               const Real marketDefaultableBond, Real& h0, Real& sigma, const Array& p,
                               const std::vector<Real>& locations, const Array& dy,
                               const QuantLib::ext::shared_ptr<FdmBackwardSolver>& solver, const Real t_from, const Real t_to,
                               const Size steps, const Size dampingSteps)
                    : mode_(mode), strike_(strike), marketEquityOption_(marketEquityOption),
                      marketDefaultableBond_(marketDefaultableBond), h0_(h0), sigma_(sigma), locations_(locations),
                      dy_(dy), p_(p), solver_(solver), t_from_(t_from), t_to_(t_to), steps_(steps),
                      dampingSteps_(dampingSteps) {}
 
                Array values(const Array& x) const override {
 
                    // 2.2.2.0 set trial values from optimiser for h0 and sigma, we square the values to ensure
                    // positivity, this transformation is reverted when setting the guess and reading the solution
 
                    if (mode_ == Mode::h0) {
                        h0_ = hToReal(x[0]);
                    } else if (mode_ == Mode::sigma) {
                        sigma_ = sigmaToReal(x[0]);
                    } else {
                        h0_ = hToReal(x[0]);
                        sigma_ = sigmaToReal(x[1]);
                    }
 
                    // 2.2.2.1 roll density back (in "time to maturity", not in calendar time, which rolls forward)
 
                    Array pTmp = p_;
                    solver_->rollback(pTmp, t_from_, t_to_, steps_, dampingSteps_);
 
                    // 2.2.2.2 compute model defaultable zero bond and equity call option
 
                    Real defaultableBond = 0.0;
                    if (mode_ == Mode::h0 || mode_ == Mode::both) {
                        for (Size i = 0; i < pTmp.size(); ++i) {
                            defaultableBond += pTmp[i] * dy_[i];
                        }
                    }
 
                    Real equityOption = 0.0;
                    if (mode_ == Mode::sigma || mode_ == Mode::both) {
                        bool knockInLocation = true;
                        for (Size i = 0; i < pTmp.size(); ++i) {
                            if (locations_[i] > std::log(strike_) && !close_enough(locations_[i], std::log(strike_))) {
                                Real dy = dy_[i];
                                if (knockInLocation) {
                                    // TODO there are more sophisticated corrections (reference in the Andersen paper?)
                                    dy = (locations_[i] - std::log(strike_));
                                    if (i < pTmp.size())
                                        dy += 0.5 * (locations_[i + 1] - locations_[i]);
                                    else
                                        dy += 0.5 * (locations_[i] - locations_[i - 1]);
                                    knockInLocation = false;
                                }
                                equityOption += pTmp[i] * dy * (std::exp(locations_[i]) - strike_);
                            }
                        }
                    }
 
                    if (mode_ == Mode::h0) {
                        Array result(1);
                        result[0] = (defaultableBond - marketDefaultableBond_) / marketDefaultableBond_;
                        return result;
                    } else if (mode_ == Mode::sigma) {
                        Array result(1);
                        result[0] = (equityOption - marketEquityOption_) / marketEquityOption_;
                        return result;
                    } else {
                        Array result(2);
                        result[0] = (defaultableBond - marketDefaultableBond_) / marketDefaultableBond_;
                        result[1] = (equityOption - marketEquityOption_) / marketEquityOption_;
                        return result;
                    }
                }
                const Mode mode_;
                const Real strike_, marketEquityOption_, marketDefaultableBond_;
                Real &h0_, &sigma_;
                const std::vector<Real>& locations_;
                const Array &dy_, &p_;
                const QuantLib::ext::shared_ptr<FdmBackwardSolver> solver_;
                const Real t_from_, t_to_;
                const Size steps_, dampingSteps_;
            };
 
            /* 2.2.2.3 The first guess (i=0) are parameters computed with p = 0 as above.
                       A subsequent guess (i>0) is the last solution that resulted in an
                       error below a given threshold (or the guess for i=0 if that is the
                       only available guess). */
 
            if (i == 0) {
                guess[0] = -std::log(creditCurve_->survivalProbability(stepTimes_[i]) /
                                     (i == 0 ? 1.0 : creditCurve_->survivalProbability(stepTimes_[i - 1]))) /
                           (stepTimes_[i] - (i == 0 ? 0.0 : stepTimes_[i - 1]));
                guess[1] = std::sqrt(volatility->blackVariance(stepTimes_[i], forward) /
                                     (stepTimes_[i] - (i == 0 ? 0.0 : stepTimes_[i - 1])));
                lastValidGuess = guess;
            } else {
                if (lastOptimizationError < thresholdSuccessfulOptimization) {
                    guess[0] = h0_[i - 1];
                    guess[1] = sigma_[i - 1];
                    lastValidGuess = guess;
                } else {
                    guess = lastValidGuess;
                }
            }
 
            // 2.2.2.4 transform the guess
 
            guess[0] = TargetFunction::hToOpt(guess[0]);
            guess[1] = TargetFunction::sigmaToOpt(guess[1]);
 
            // 2.2.2.5 run the optimzation for the current time step and set the model parameters to the found solution
 
            Real t_from = stepTimes_.back() - (i == 0 ? 0.0 : stepTimes_[i - 1]);
            Real t_to = stepTimes_.back() - stepTimes_[i];
            Size steps = static_cast<Size>(0.5 + (t_from - t_to) * static_cast<Real>(timeStepsPerYear));
 
            NoConstraint noConstraint;
            LevenbergMarquardt lm;
            EndCriteria endCriteria(100, 10, 1E-8, 1E-8, 1E-8);
            if (bootstrapMode == DefaultableEquityJumpDiffusionModelBuilder::BootstrapMode::Simultaneously) {
                // simultaneous optimization of (h0,sigma)
                TargetFunction targetFunction(TargetFunction::Mode::both, forward, marketEquityOption,
                                              marketDefaultableBond, h0_[i], sigma_[i], p, mesher_->locations(), dy,
                                              solver, t_from, t_to, steps, i == 0 ? dampingSteps : 0);
                Problem problem(targetFunction, noConstraint, guess);
                lm.minimize(problem, endCriteria);
                h0_[i] = TargetFunction::hToReal(problem.currentValue()[0]);
                sigma_[i] = TargetFunction::sigmaToReal(problem.currentValue()[1]);
                lastOptimizationError = problem.functionValue();
            } else {
                // alternating optimization of h0 and sigma
                TargetFunction target_function_h0(TargetFunction::Mode::h0, forward, marketEquityOption,
                                                  marketDefaultableBond, h0_[i], sigma_[i], p, mesher_->locations(), dy,
                                                  solver, t_from, t_to, steps, i == 0 ? dampingSteps : 0);
                TargetFunction target_function_sigma(TargetFunction::Mode::sigma, forward, marketEquityOption,
                                                     marketDefaultableBond, h0_[i], sigma_[i], p, mesher_->locations(),
                                                     dy, solver, t_from, t_to, steps, i == 0 ? dampingSteps : 0);
                Real current0 = guess[0], current1 = guess[1];
                Real delta0 = 0.0, delta1 = 0.0;
                Real functionValue0 = 0.0, functionValue1 = 0.0;
                Size iteration = 0;
                constexpr Real tol_x = 1E-8;
                do {
                    // optimize h0
                    Problem p0(target_function_h0, noConstraint, Array(1, current0));
                    lm.minimize(p0, endCriteria);
                    h0_[i] = TargetFunction::hToReal(p0.currentValue()[0]);
                    delta0 = std::abs(h0_[i] - TargetFunction::hToReal(current0));
                    current0 = p0.currentValue()[0];
                    functionValue0 = p0.functionValue();
                    // optimize sigma
                    Problem p1(target_function_sigma, noConstraint, Array(1, current1));
                    lm.minimize(p1, endCriteria);
                    sigma_[i] = TargetFunction::sigmaToReal(p1.currentValue()[0]);
                    delta1 = std::abs(sigma_[i] - TargetFunction::sigmaToReal(current1));
                    current1 = p1.currentValue()[0];
                    functionValue1 = p1.functionValue();
                } while (iteration++ < 50 && (delta0 > tol_x || delta1 > tol_x));
                lastOptimizationError =
                    std::sqrt(0.5 * (functionValue0 * functionValue0 + functionValue1 * functionValue1));
            }
 
            // 2.2.2.6 we still have to do the actual roll back with the solution we have found
 
            solver->rollback(p, t_from, t_to, steps, i == 0 ? dampingSteps : 0);
 
        } // bootstrap over step times
    }     // case p!= 0
}

Here is the call graph for this function:

update()

void update ( )

override

Definition at line 161 of file defaultableequityjumpdiffusionmodel.cpp.

{ notifyObservers(); }

getTimeIndex()

Size getTimeIndex ( const Real  t ) const

private

Definition at line 189 of file defaultableequityjumpdiffusionmodel.cpp.

                                                                         {
    Size m = std::distance(stepTimes_.begin(),
                           std::lower_bound(stepTimes_.begin(), stepTimes_.end(), t,
                                            [](Real x, Real y) { return x < y && !close_enough(x, y); }));
    return std::min(m, stepTimes_.size() - 1);
}

Here is the caller graph for this function:

Member Data Documentation

stepTimes_

std::vector<Real> stepTimes_

private

Definition at line 168 of file defaultableequityjumpdiffusionmodel.hpp.

h0_

std::vector<Real> h0_

mutableprivate

Definition at line 169 of file defaultableequityjumpdiffusionmodel.hpp.

sigma_

std::vector<Real> sigma_

private

Definition at line 169 of file defaultableequityjumpdiffusionmodel.hpp.

equity_

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

private

Definition at line 170 of file defaultableequityjumpdiffusionmodel.hpp.

creditCurve_

Handle<DefaultProbabilityTermStructure> creditCurve_

private

Definition at line 171 of file defaultableequityjumpdiffusionmodel.hpp.

volDayCounter_

DayCounter volDayCounter_

private

Definition at line 172 of file defaultableequityjumpdiffusionmodel.hpp.

p_

Real p_

private

Definition at line 173 of file defaultableequityjumpdiffusionmodel.hpp.

eta_

Real eta_

private

Definition at line 173 of file defaultableequityjumpdiffusionmodel.hpp.

adjustEquityForward_

bool adjustEquityForward_

private

Definition at line 174 of file defaultableequityjumpdiffusionmodel.hpp.

mesher_

QuantLib::ext::shared_ptr<Fdm1dMesher> mesher_

mutableprivate

Definition at line 177 of file defaultableequityjumpdiffusionmodel.hpp.

totalBlackVariance_

Real totalBlackVariance_ = 1.0

mutableprivate

Definition at line 180 of file defaultableequityjumpdiffusionmodel.hpp.

fh_

constexpr Real fh_ = 1E-4

staticconstexprprivate

Definition at line 183 of file defaultableequityjumpdiffusionmodel.hpp.