LgmConvolutionSolver Class Reference

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

#include <qle/pricingengines/lgmconvolutionsolver.hpp>

Inheritance diagram for LgmConvolutionSolver:

Collaboration diagram for LgmConvolutionSolver:

Public Member Functions
	LgmConvolutionSolver (const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &model, const Real sy, const Size ny, const Real sx, const Size nx)
	Numerical convolution solver for the LGM model. More...
Size	gridSize () const
std::vector< Real >	stateGrid (const Real t) const
template<typename ValueType = Real>
std::vector< ValueType >	rollback (const std::vector< ValueType > &v, const Real t1, const Real t0, const ValueType zero=ValueType(0.0)) const
const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &	model () const

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 36 of file lgmconvolutionsolver.hpp.

Constructor & Destructor Documentation

LgmConvolutionSolver()

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

Numerical convolution solver for the LGM model.

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

Definition at line 30 of file lgmconvolutionsolver.cpp.

    : model_(model), nx_(nx) {
 
    // precompute weights
 
    // number of x, y grid points > 0
    mx_ = static_cast<Size>(floor(sx * static_cast<Real>(nx)) + 0.5);
    my_ = static_cast<Size>(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

Definition at line 42 of file lgmconvolutionsolver.hpp.

{ return 2 * mx_ + 1; }

Here is the caller graph for this function:

stateGrid()

std::vector< Real > stateGrid

(

const Real

t

)

const

Definition at line 65 of file lgmconvolutionsolver.cpp.

                                                                  {
    if (close_enough(t, 0.0))
        return std::vector<Real>(2 * mx_ + 1, 0.0);
    std::vector<Real> 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[k] = dx * (k - mx_);
    }
    return x;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rollback()

std::vector< ValueType > rollback	(	const std::vector< ValueType > &	v,
		const Real	t1,
		const Real	t0,
		const ValueType	zero = ValueType(0.0)
	)		const

Definition at line 65 of file lgmconvolutionsolver.hpp.

                                                                                  {
    if (QuantLib::close_enough(t0, t1))
        return v;
    QL_REQUIRE(t0 < t1, "LgmConvolutionSolver::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
        ValueType value(zero);
        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 std::vector<ValueType>(2 * mx_ + 1, value);
    } else {
        std::vector<ValueType> value(2 * mx_ + 1, zero);
        // 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[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 caller graph for this function:

model()

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

(

)

const

Definition at line 53 of file lgmconvolutionsolver.hpp.

{ return model_; }

Here is the caller graph for this function:

Member Data Documentation

model_

QuantLib::ext::shared_ptr<LinearGaussMarkovModel> model_

private

Definition at line 56 of file lgmconvolutionsolver.hpp.

mx_

int mx_

private

Definition at line 57 of file lgmconvolutionsolver.hpp.

my_

int my_

private

Definition at line 57 of file lgmconvolutionsolver.hpp.

nx_

int nx_

private

Definition at line 57 of file lgmconvolutionsolver.hpp.

h_

Real h_

private

Definition at line 58 of file lgmconvolutionsolver.hpp.

y_

std::vector<Real> y_

private

Definition at line 59 of file lgmconvolutionsolver.hpp.

w_

std::vector<Real> w_

private

Definition at line 59 of file lgmconvolutionsolver.hpp.