Cox-Ingersoll-Ross ++ credit model class. More...

#include <qle/models/crcirpp.hpp>

Inheritance diagram for CrCirpp:

Collaboration diagram for CrCirpp:

Public Member Functions
	CrCirpp (const QuantLib::ext::shared_ptr< CrCirppParametrization > &parametrization)

Real	zeroBond (Real t, Real T, Real y) const

Real	survivalProbability (Real t, Real T, Real y) const

Real	densityForwardMeasure (Real x, Real t)

Real	cumulativeForwardMeasure (Real x, Real t)

Real	density (Real x, Real t)

Real	cumulative (Real x, Real t)

Real	zeroBondOption (Real eval_t, Real expiry_T, Real maturity_tau, Real strike_k, Real y_t, Real w)

Handle< DefaultProbabilityTermStructure >	defaultCurve (std::vector< Date > dateGrid=std::vector< Date >()) const

const QuantLib::ext::shared_ptr< CrCirppParametrization >	parametrization () const

const QuantLib::ext::shared_ptr< StochasticProcess >	stateProcess () const

Real	A (Real t, Real T) const

Real	B (Real t, Real T) const

void	update () override

void	generateArguments () override

Public Member Functions inherited from LinkableCalibratedModel
	LinkableCalibratedModel ()

void	update () override

virtual void	calibrate (const std::vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >(), const std::vector< bool > &fixParameters=std::vector< bool >())
	Calibrate to a set of market instruments (usually caps/swaptions) More...

virtual void	calibrate (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >(), const std::vector< bool > &fixParameters=std::vector< bool >())
	for backward compatibility More...

Real	value (const Array &params, const std::vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &)

Real	value (const Array &params, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &)
	for backward compatibility More...

const QuantLib::ext::shared_ptr< Constraint > &	constraint () const

EndCriteria::Type	endCriteria () const
	Returns end criteria result. More...

const Array &	problemValues () const
	Returns the problem values. More...

Array	params () const
	Returns array of arguments on which calibration is done. More...

virtual void	setParams (const Array &params)

virtual void	setParam (Size idx, const Real value)

Private Attributes
QuantLib::ext::shared_ptr< CrCirppParametrization >	parametrization_

QuantLib::ext::shared_ptr< CrCirppStateProcess >	stateProcess_

Additional Inherited Members
virtual void	generateArguments ()

Protected Attributes inherited from LinkableCalibratedModel
std::vector< QuantLib::ext::shared_ptr< Parameter > >	arguments_

QuantLib::ext::shared_ptr< Constraint >	constraint_

EndCriteria::Type	endCriteria_

Array	problemValues_

Detailed Description

Cox-Ingersoll-Ross ++ credit model class.

This class implements the Cox-Ingersoll-Ross model defined by

\[ \lambda(t) = y(t) + \psi (t) \\ dy(t) = a(\theta - y(t)) dt + \sigma \, \sqrt{y(t)} \, dW \]

Definition at line 48 of file crcirpp.hpp.

Constructor & Destructor Documentation

◆ CrCirpp()

CrCirpp ( const QuantLib::ext::shared_ptr< CrCirppParametrization > & parametrization )

Definition at line 42 of file crcirpp.cpp.

    : parametrization_(parametrization) {
 
    // FIXME hardcoded discretisation schema
    stateProcess_ =
        QuantLib::ext::make_shared<CrCirppStateProcess>(this, CrCirppStateProcess::Discretization::BrigoAlfonsi);
    QL_REQUIRE(stateProcess_ != NULL, "stateProcess has null pointer in CrCirpp ctor!");
 
    arguments_.resize(4);
    arguments_[0] = parametrization_->parameter(0);
    arguments_[1] = parametrization_->parameter(1);
    arguments_[2] = parametrization_->parameter(2);
    arguments_[3] = parametrization_->parameter(3);
    registerWith(parametrization_->termStructure());
}

Member Function Documentation

◆ zeroBond()

Real zeroBond	(	Real	t,
		Real	T,
		Real	y
	)		const

Definition at line 124 of file crcirpp.cpp.

124{ return A(t, T) * exp(-B(t, T) * y); }

QuantExt::CrCirpp::A

Real A(Real t, Real T) const

Definition: crcirpp.cpp:93

QuantExt::CrCirpp::B

Real B(Real t, Real T) const

Definition: crcirpp.cpp:109

QuantExt::exp

CompiledFormula exp(CompiledFormula x)

Definition: compiledformula.cpp:151

Here is the call graph for this function:

Here is the caller graph for this function:

◆ survivalProbability()

Real survivalProbability	(	Real	t,
		Real	T,
		Real	y
	)		const

Definition at line 126 of file crcirpp.cpp.

                                                              {
    Real P_Cir = zeroBond(t, T, y); // A(t,T) * exp(-B(t,T) * y);
    if (parametrization_->shifted()) {
        Probability SP_t = parametrization_->termStructure()->survivalProbability(t);
        // std::cout<<" SP_t  " << SP_t << std::endl;
        Probability SP_T = parametrization_->termStructure()->survivalProbability(T);
        // std::cout<<" SP_T " << SP_T << std::endl;
        // std::cout<<" y0  " << parametrization_->y0(t) << std::endl;
        Real A_bar = (SP_T * A(0, t) * exp(-B(0, t) * parametrization_->y0(t))) /
                     (SP_t * A(0, T) * exp(-B(0, T) * parametrization_->y0(t)));
        // std::cout<<"A_bar " <<A_bar<< std::endl;
        return A_bar * P_Cir;
    } else
        return P_Cir;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ densityForwardMeasure()

Real densityForwardMeasure	(	Real	x,
		Real	t
	)

Definition at line 176 of file crcirpp.cpp.

                                                  {
 
    Real kappa = parametrization_->kappa(t);
    Real theta = parametrization_->theta(t);
    Real sigma = parametrization_->sigma(t);
    Real y0 = parametrization_->y0(t);
    Real sigma2 = sigma * sigma;
 
    Real h = sqrt(kappa * kappa + 2.0 * sigma2);
    Real rho = 2 * h / (sigma2 * (exp(h * t) - 1));
    // q(t,s) in Brigo-Mercuri in (3.28)
    Real c = 2 * (rho + (kappa + h) / sigma2 + 0.0); // 0.0 stands for the B term which is neglectible
    // degrees of freedom
    Real df = 4 * kappa * theta / (sigma2);
    // non-central parameter
    // delta(t,s) in Brigo-Mercurio in (3.28)
    Real ncp = 4 * (rho * rho * y0 * exp(h * t)) / c;
 
    return c * nccs(df, ncp, c * x, false);
}

Here is the call graph for this function:

◆ cumulativeForwardMeasure()

Real cumulativeForwardMeasure	(	Real	x,
		Real	t
	)

Definition at line 198 of file crcirpp.cpp.

                                                     {
 
    Real kappa = parametrization_->kappa(t);
    Real theta = parametrization_->theta(t);
    Real sigma = parametrization_->sigma(t);
    Real y0 = parametrization_->y0(t);
    Real sigma2 = sigma * sigma;
    Real h = sqrt(kappa * kappa + 2.0 * sigma2);
    Real rho = 2 * h / (sigma2 * (exp(h * t) - 1));
 
    // q(t,s) in Brigo-Mercurii (3.28)
    Real c = 2 * (rho + (kappa + h) / sigma2 + 0.0); // 0.0 stands for the B term which is neglectible
    // degrees of freedom
    Real df = 4 * kappa * theta / (sigma2);
    // non-central parameter
    // delta(t,s) in Brigo-Mercurio in (3.28)
    Real ncp = 4 * (rho * rho * y0 * exp(h * t)) / c;
 
    return c * nccs(df, ncp, c * x, true);
}

Here is the call graph for this function:

◆ density()

Real density	(	Real	x,
		Real	t
	)

Definition at line 142 of file crcirpp.cpp.

                                    {
 
    Real kappa = parametrization_->kappa(t);
    Real theta = parametrization_->theta(t);
    Real sigma = parametrization_->sigma(t);
    Real y0 = parametrization_->y0(t);
    Real sigma2 = sigma * sigma;
 
    Real c = 4 * kappa / (sigma2 * (1 - exp(-kappa * t)));
    // degrees of freedom
    Real df = 4 * kappa * theta / (sigma2);
    // non-central parameter
    Real ncp = c * y0 * exp(-kappa * t);
 
    return c * nccs(df, ncp, c * x, false);
}

Here is the call graph for this function:

◆ cumulative()

Real cumulative	(	Real	x,
		Real	t
	)

Definition at line 159 of file crcirpp.cpp.

                                       {
 
    Real kappa = parametrization_->kappa(t);
    Real theta = parametrization_->theta(t);
    Real sigma = parametrization_->sigma(t);
    Real y0 = parametrization_->y0(t);
    Real sigma2 = sigma * sigma;
 
    Real c = 4 * kappa / (sigma2 * (1 - exp(-kappa * t)));
    // degrees of freedom
    Real df = 4 * kappa * theta / (sigma2);
    // non-central parameter
    Real ncp = c * y0 * exp(-kappa * t);
 
    return c * nccs(df, ncp, c * x, true);
}

Here is the call graph for this function:

◆ zeroBondOption()

Real zeroBondOption	(	Real	eval_t,
		Real	expiry_T,
		Real	maturity_tau,
		Real	strike_k,
		Real	y_t,
		Real	w
	)

Definition at line 220 of file crcirpp.cpp.

                                                      {
 
    Real value = 0.0;
    Real kappa = parametrization_->kappa(eval_t);
    Real theta = parametrization_->theta(eval_t);
    Real sigma = parametrization_->sigma(eval_t);
    Real y0 = parametrization_->y0(eval_t);
    Real sigma2 = sigma * sigma;
 
    Real h = sqrt(kappa * kappa + 2.0 * sigma2);
    Real rho = 2.0 * h / (sigma2 * (exp(h * (expiry_T - eval_t)) - 1.0));
    Real Psi = (kappa + h) / sigma2;
 
    Probability SP_T;
    Probability SP_tau;
    if (parametrization_->shifted()) {
        SP_T = parametrization()->termStructure()->survivalProbability(expiry_T);
        SP_tau = parametrization()->termStructure()->survivalProbability(maturity_tau);
    } else {
        SP_T = survivalProbability(0.0, expiry_T, y0);
        SP_tau = survivalProbability(0.0, maturity_tau, y0);
    }
 
    Real r_hat = 1.0 / B(expiry_T, maturity_tau) *
                 (log(A(expiry_T, maturity_tau) / strike_k) -
                  log((SP_T * A(0.0, maturity_tau) * exp(-B(0.0, maturity_tau) * y0)) /
                      (SP_tau * A(0.0, expiry_T) * exp(-B(0.0, expiry_T) * y0))));
 
    Real denom = rho + Psi + B(expiry_T, maturity_tau);
    Real df = 4.0 * kappa * theta / sigma2;
    Real ncp = 2.0 * rho * rho * y_t * exp(h * (expiry_T - eval_t)) / denom;
    QL_REQUIRE(std::isfinite(df) && df > 0, "CrCirpp::zeroBondOption(): illegal df="
                                                << df << ", kappa=" << kappa << ", theta= " << theta
                                                << ", sigma=" << sigma);
 
    value += nccs(df, ncp, 2 * r_hat * denom, true) * SP_tau;
 
    denom = rho + Psi;
    // df unchanged
    ncp = 2 * rho * rho * y_t * exp(h * (expiry_T - eval_t)) / denom;
 
    value -= nccs(df, ncp, 2 * r_hat * denom, true) * SP_T * strike_k;
 
    if (w < 0.0) {
        // PUT via put-call-paritiy
        // C - P = S_M(T) - S_M(t)*K
        // P = C - S_M(T) + S_M(t)*K
        value -= SP_tau - SP_T * strike_k;
    }
 
    return value;
}

Here is the call graph for this function:

◆ defaultCurve()

Handle< DefaultProbabilityTermStructure > defaultCurve ( std::vector< Date > dateGrid = std::vector<Date>() ) const

Definition at line 59 of file crcirpp.cpp.

                                                                                            {
    if (parametrization_->shifted()) {
        QL_REQUIRE(!parametrization_->termStructure().empty(), "default curve not set");
        QL_REQUIRE(dateGrid.size() == 0, "dateGrid without effect for shifted model");
        return parametrization_->termStructure();
    } else {
        // build one on the fly
        Date today = Settings::instance().evaluationDate();
        std::vector<Real> survivalProbabilities(1, 1.0);
        std::vector<Date> dates;
        DayCounter tsDayCounter = Actual365Fixed();
        if (dateGrid.size() > 0) {
            QL_REQUIRE(dateGrid.front() == today, "front date must be today");
            dates = dateGrid;
        } else {
            dates.push_back(today);
            // up to one year in monthly steps
            for (Size i = 1; i <= 12; i++)
                dates.push_back(today + i * Months);
            // starts in year two annually
            for (Size i = 2; i <= 10; i++)
                dates.push_back(today + i * Years);
        }
        for (Size i = 1; i < dates.size(); i++) {
            Real t = tsDayCounter.yearFraction(today, dates[i]);
            survivalProbabilities.push_back(survivalProbability(0.0, t, parametrization_->y0(t)));
        }
        QuantLib::ext::shared_ptr<DefaultProbabilityTermStructure> defaultCurve(
            new InterpolatedSurvivalProbabilityCurve<LogLinear>(dates, survivalProbabilities, tsDayCounter));
        defaultCurve->enableExtrapolation();
        return Handle<DefaultProbabilityTermStructure>(defaultCurve);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parametrization()

const QuantLib::ext::shared_ptr< CrCirppParametrization > parametrization ( ) const

Definition at line 88 of file crcirpp.hpp.

                                                                                          {
    return parametrization_;
}

Here is the caller graph for this function:

◆ stateProcess()

const QuantLib::ext::shared_ptr< StochasticProcess > stateProcess ( ) const

Definition at line 92 of file crcirpp.hpp.

                                                                                  {
    QL_REQUIRE(stateProcess_ != NULL, "stateProcess has null pointer in CIR++ stateProcess!");
    return stateProcess_;
}

◆ A()

Real A	(	Real	t,
		Real	T
	)		const

Definition at line 93 of file crcirpp.cpp.

                                    {
    Real kappa = parametrization_->kappa(t);
    Real theta = parametrization_->theta(t);
    Real sigma = parametrization_->sigma(t);
    Real sigma2 = sigma * sigma;
    Real h = sqrt(kappa * kappa + 2.0 * sigma2);
 
    Real nominator = 2.0 * h * exp((kappa + h) * (T - t) / 2.0);
    Real denominator = 2.0 * h + (kappa + h) * (exp((T - t) * h) - 1.0);
    Real exponent = 2.0 * kappa * theta / sigma2;
 
    Real value = std::pow((nominator / denominator), exponent);
 
    return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ B()

Real B	(	Real	t,
		Real	T
	)		const

Definition at line 109 of file crcirpp.cpp.

                                    {
 
    Real kappa = parametrization_->kappa(t);
    Real sigma = parametrization_->sigma(t);
    Real sigma2 = sigma * sigma;
    Real h = sqrt(kappa * kappa + 2.0 * sigma2);
 
    Real nominator = 2.0 * (exp((T - t) * h) - 1.0);
    Real denominator = 2.0 * h + (kappa + h) * (exp((T - t) * h) - 1.0);
 
    Real value = nominator / denominator;
 
    return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update()

void update ( )

override

observer and linked calibrated model interface

Definition at line 81 of file crcirpp.hpp.

                            {
    notifyObservers();
    parametrization_->update();
}

Here is the caller graph for this function:

◆ generateArguments()

void generateArguments ( )

overridevirtual

Reimplemented from LinkableCalibratedModel.

Definition at line 86 of file crcirpp.hpp.

86{ update(); }

QuantExt::CrCirpp::update

void update() override

Definition: crcirpp.hpp:81

Here is the call graph for this function:

Member Data Documentation

◆ parametrization_

QuantLib::ext::shared_ptr<CrCirppParametrization> parametrization_

private

Definition at line 77 of file crcirpp.hpp.

◆ stateProcess_

QuantLib::ext::shared_ptr<CrCirppStateProcess> stateProcess_

private

Definition at line 78 of file crcirpp.hpp.

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CrCirpp()

Member Function Documentation

◆ zeroBond()

◆ survivalProbability()

◆ densityForwardMeasure()

◆ cumulativeForwardMeasure()

◆ density()

◆ cumulative()

◆ zeroBondOption()

◆ defaultCurve()

◆ parametrization()

◆ stateProcess()

◆ A()

◆ B()

◆ update()

◆ generateArguments()

Member Data Documentation

◆ parametrization_

◆ stateProcess_