LgmConvolutionSolver2 Class Reference

Numerical convolution solver for the LGM model. More...

#include <qle/models/lgmconvolutionsolver2.hpp>

Inheritance diagram for LgmConvolutionSolver2:

Collaboration diagram for LgmConvolutionSolver2:

Public Member Functions
	LgmConvolutionSolver2 (const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &model, const Real sy, const Size ny, const Real sx, const Size nx)
Size	gridSize () const override
RandomVariable	stateGrid (const Real t) const override
RandomVariable	rollback (const RandomVariable &v, const Real t1, const Real t0, Size steps=Null< Size >()) const override
const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &	model () const override
Public Member Functions inherited from LgmBackwardSolver
virtual	~LgmBackwardSolver ()
virtual Size	gridSize () const =0
virtual RandomVariable	stateGrid (const Real t) const =0
virtual RandomVariable	rollback (const RandomVariable &v, const Real t1, const Real t0, Size steps=Null< Size >()) const =0
virtual const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &	model () const =0

Private Attributes
QuantLib::ext::shared_ptr< LinearGaussMarkovModel >	model_
int	mx_
int	my_
int	nx_
Real	h_
std::vector< Real >	y_
std::vector< Real >	w_

Detailed Description

Numerical convolution solver for the LGM model.

Reference: Hagan, Methodology for callable swaps and Bermudan exercise into swaptions

Definition at line 37 of file lgmconvolutionsolver2.hpp.

Constructor & Destructor Documentation

LgmConvolutionSolver2()

LgmConvolutionSolver2	(	const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &	model,
		const Real	sy,
		const Size	ny,
		const Real	sx,
		const Size	nx
	)

Definition at line 25 of file lgmconvolutionsolver2.cpp.

    : model_(model), nx_(static_cast<int>(nx)) {
 
    // precompute weights
 
    // number of x, y grid points > 0
    mx_ = static_cast<int>(floor(sx * static_cast<Real>(nx)) + 0.5);
    my_ = static_cast<int>(floor(sy * static_cast<Real>(ny)) + 0.5);
 
    // y-grid spacing
    h_ = 1.0 / static_cast<Real>(ny);
 
    // weights for convolution in the rollback step
    CumulativeNormalDistribution N;
    NormalDistribution G;
 
    y_.resize(2 * my_ + 1); // x-coordinate / standard deviation of x
    w_.resize(2 * my_ + 1); // probability weight around y-grid point i
    for (int i = 0; i <= 2 * my_; i++) {
        y_[i] = h_ * (i - my_);
        if (i == 0 || i == 2 * my_)
            w_[i] = (1. + y_[0] / h_) * N(y_[0] + h_) - y_[0] / h_ * N(y_[0]) + (G(y_[0] + h_) - G(y_[0])) / h_;
        else
            w_[i] = (1. + y_[i] / h_) * N(y_[i] + h_) - 2. * y_[i] / h_ * N(y_[i]) -
                    (1. - y_[i] / h_) * N(y_[i] - h_) // opposite sign in the paper
                    + (G(y_[i] + h_) - 2. * G(y_[i]) + G(y_[i] - h_)) / h_;
        // w_[i] might be negative due to numerical errors
        if (w_[i] < 0.0) {
            QL_REQUIRE(w_[i] > -1.0E-10, "LgmConvolutionSolver: negative w (" << w_[i] << ") at i=" << i);
            w_[i] = 0.0;
        }
    }
}

Member Function Documentation

gridSize()

Size gridSize ( ) const

overridevirtual

Implements LgmBackwardSolver.

Definition at line 41 of file lgmconvolutionsolver2.hpp.

{ return 2 * mx_ + 1; }

stateGrid()

RandomVariable stateGrid ( const Real  t ) const

overridevirtual

Implements LgmBackwardSolver.

Definition at line 60 of file lgmconvolutionsolver2.cpp.

                                                                  {
    if (QuantLib::close_enough(t, 0.0))
        return RandomVariable(2 * mx_ + 1, 0.0);
    RandomVariable x(2 * mx_ + 1);
    Real dx = std::sqrt(model_->parametrization()->zeta(t)) / static_cast<Real>(nx_);
    for (int k = 0; k <= 2 * mx_; ++k) {
        x.set(k, dx * (k - mx_));
    }
    return x;
}

Here is the call graph for this function:

rollback()

RandomVariable rollback ( const RandomVariable &  v, const Real  t1, const Real  t0, Size  steps = Null<Size>()  ) const

overridevirtual

Implements LgmBackwardSolver.

Definition at line 71 of file lgmconvolutionsolver2.cpp.

                                                                                                                {
    if (QuantLib::close_enough(t0, t1) || v.deterministic())
        return v;
    QL_REQUIRE(t0 < t1, "LgmConvolutionSolver2::rollback(): t0 (" << t0 << ") < t1 (" << t1 << ") required.");
    Real sigma = std::sqrt(model_->parametrization()->zeta(t1));
    Real dx = sigma / static_cast<Real>(nx_);
    if (QuantLib::close_enough(t0, 0.0)) {
        // rollback from t1 to t0 = 0
        Real value = 0.0;
        for (int i = 0; i <= 2 * my_; i++) {
            // Map y index to x index, not integer in general
            Real kp = y_[i] * sigma / dx + mx_;
            // Adjacent integer x index <= k
            int kk = int(floor(kp));
            // Get value at kp by linear interpolation on
            // kk <= kp <= kk + 1 with flat extrapolation
            value +=
                w_[i] *
                (kk < 0 ? v[0] : (kk + 1 > 2 * mx_ ? v[2 * mx_] : (kp - kk) * v[kk + 1] + (1.0 + kk - kp) * v[kk]));
        }
        return RandomVariable(2 * mx_ + 1, value);
    } else {
        RandomVariable value(2 * mx_ + 1, 0.0);
        value.expand();
        // rollback from t1 to t0 > 0
        Real std = std::sqrt(model_->parametrization()->zeta(t1) - model_->parametrization()->zeta(t0));
        Real dx2 = std::sqrt(model_->parametrization()->zeta(t0)) / static_cast<Real>(nx_);
        for (int k = 0; k <= 2 * mx_; k++) {
            for (int i = 0; i <= 2 * my_; i++) {
                // Map y index to x index, not integer in generalTo
                Real kp = (dx2 * (k - mx_) + y_[i] * std) / dx + mx_;
                // Adjacent integer x index <= k
                int kk = int(floor(kp));
                // Get value at kp by linear interpolation on
                // kk <= kp <= kk + 1 with flat extrapolation
                value.set(k, value[k] + w_[i] * (kk < 0 ? v[0]
                                                        : (kk + 1 > 2 * mx_
                                                               ? v[2 * mx_]
                                                               : (kp - kk) * v[kk + 1] + (1.0 + kk - kp) * v[kk])));
            }
        }
        return value;
    }
}

Here is the call graph for this function:

model()

const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > & model ( ) const

overridevirtual

Implements LgmBackwardSolver.

Definition at line 46 of file lgmconvolutionsolver2.hpp.

{ return model_; }

Member Data Documentation

model_

QuantLib::ext::shared_ptr<LinearGaussMarkovModel> model_

private

Definition at line 49 of file lgmconvolutionsolver2.hpp.

mx_

int mx_

private

Definition at line 50 of file lgmconvolutionsolver2.hpp.

my_

int my_

private

Definition at line 50 of file lgmconvolutionsolver2.hpp.

nx_

int nx_

private

Definition at line 50 of file lgmconvolutionsolver2.hpp.

h_

Real h_

private

Definition at line 51 of file lgmconvolutionsolver2.hpp.

y_

std::vector<Real> y_

private

Definition at line 52 of file lgmconvolutionsolver2.hpp.

w_

std::vector<Real> w_

private

Definition at line 52 of file lgmconvolutionsolver2.hpp.