SwaptionVolatilityEUR Struct Reference

#include <test/swaptionmarketdata.hpp>

Collaboration diagram for SwaptionVolatilityEUR:

Public Member Functions
	SwaptionVolatilityEUR ()

Public Attributes
vector< Period >	optionTenors
vector< Period >	swapTenors
vector< Real >	strikeSpreads
Matrix	nVols
Matrix	lnVols
Matrix	slnVols_1
Matrix	slnVols_2
Matrix	shifts_1
Matrix	shifts_2
vector< vector< Handle< Quote > > >	nVolSpreads
vector< vector< Handle< Quote > > >	lnVolSpreads
vector< vector< Handle< Quote > > >	slnVolSpreads

Detailed Description

Definition at line 42 of file swaptionmarketdata.hpp.

Constructor & Destructor Documentation

SwaptionVolatilityEUR()

SwaptionVolatilityEUR

(

)

Definition at line 44 of file swaptionmarketdata.hpp.

        : optionTenors(4), swapTenors(4), strikeSpreads(5), nVols(optionTenors.size(), swapTenors.size(), 0.0),
          lnVols(nVols), slnVols_1(nVols), slnVols_2(nVols), shifts_1(nVols), shifts_2(nVols),
          nVolSpreads(16, vector<Handle<Quote> >(5, Handle<Quote>())),
          lnVolSpreads(16, vector<Handle<Quote> >(5, Handle<Quote>())),
          slnVolSpreads(16, vector<Handle<Quote> >(5, Handle<Quote>())) {
 
        // Populate option tenors
        optionTenors[0] = Period(1, Years);
        optionTenors[1] = Period(5, Years);
        optionTenors[2] = Period(7, Years);
        optionTenors[3] = Period(10, Years);
 
        // Populate swap tenors
        swapTenors[0] = Period(1, Years);
        swapTenors[1] = Period(5, Years);
        swapTenors[2] = Period(10, Years);
        swapTenors[3] = Period(20, Years);
 
        // Populate the normal volatility matrix
        nVols[0][0] = 0.003543;
        nVols[0][1] = 0.005270;
        nVols[0][2] = 0.006978;
        nVols[0][3] = 0.007918;
        nVols[1][0] = 0.007013;
        nVols[1][1] = 0.007443;
        nVols[1][2] = 0.007820;
        nVols[1][3] = 0.007363;
        nVols[2][0] = 0.007519;
        nVols[2][1] = 0.007807;
        nVols[2][2] = 0.007698;
        nVols[2][3] = 0.007117;
        nVols[3][0] = 0.007668;
        nVols[3][1] = 0.007705;
        nVols[3][2] = 0.007611;
        nVols[3][3] = 0.006848;
 
        // Populate the lognormal volatility matrix
        lnVols[0][0] = 2.187660;
        lnVols[0][1] = 1.748360;
        lnVols[0][2] = 0.834972;
        lnVols[0][3] = 0.663957;
        lnVols[1][0] = 0.891725;
        lnVols[1][1] = 0.642449;
        lnVols[1][2] = 0.585798;
        lnVols[1][3] = 0.512169;
        lnVols[2][0] = 0.549946;
        lnVols[2][1] = 0.552918;
        lnVols[2][2] = 0.528572;
        lnVols[2][3] = 0.476202;
        lnVols[3][0] = 0.531597;
        lnVols[3][1] = 0.534495;
        lnVols[3][2] = 0.526216;
        lnVols[3][3] = 0.462007;
 
        // Populate the first and second set of shifted lognormal volatilities
        slnVols_1[0][0] = 0.929848;
        slnVols_1[0][1] = 0.924660;
        slnVols_1[0][2] = 0.610868;
        slnVols_1[0][3] = 0.495445;
        slnVols_1[1][0] = 0.689737;
        slnVols_1[1][1] = 0.521342;
        slnVols_1[1][2] = 0.472902;
        slnVols_1[1][3] = 0.396814;
        slnVols_1[2][0] = 0.474667;
        slnVols_1[2][1] = 0.463982;
        slnVols_1[2][2] = 0.432899;
        slnVols_1[2][3] = 0.371330;
        slnVols_1[3][0] = 0.460333;
        slnVols_1[3][1] = 0.447973;
        slnVols_1[3][2] = 0.428017;
        slnVols_1[3][3] = 0.358081;
 
        slnVols_2[0][0] = 0.732040;
        slnVols_2[0][1] = 0.754222;
        slnVols_2[0][2] = 0.539085;
        slnVols_2[0][3] = 0.439887;
        slnVols_2[1][0] = 0.622370;
        slnVols_2[1][1] = 0.477238;
        slnVols_2[1][2] = 0.431955;
        slnVols_2[1][3] = 0.357137;
        slnVols_2[2][0] = 0.444718;
        slnVols_2[2][1] = 0.430028;
        slnVols_2[2][2] = 0.397564;
        slnVols_2[2][3] = 0.335037;
        slnVols_2[3][0] = 0.432003;
        slnVols_2[3][1] = 0.415209;
        slnVols_2[3][2] = 0.392379;
        slnVols_2[3][3] = 0.322612;
 
        // Populate first and second set of shifts
        shifts_1[0][0] = 0.002000;
        shifts_1[0][1] = 0.002500;
        shifts_1[0][2] = 0.003000;
        shifts_1[0][3] = 0.004000;
        shifts_1[1][0] = 0.002000;
        shifts_1[1][1] = 0.002500;
        shifts_1[1][2] = 0.003000;
        shifts_1[1][3] = 0.004000;
        shifts_1[2][0] = 0.002000;
        shifts_1[2][1] = 0.002500;
        shifts_1[2][2] = 0.003000;
        shifts_1[2][3] = 0.004000;
        shifts_1[3][0] = 0.002000;
        shifts_1[3][1] = 0.002500;
        shifts_1[3][2] = 0.003000;
        shifts_1[3][3] = 0.004000;
 
        shifts_2[0][0] = 0.003000;
        shifts_2[0][1] = 0.003750;
        shifts_2[0][2] = 0.004500;
        shifts_2[0][3] = 0.006000;
        shifts_2[1][0] = 0.003000;
        shifts_2[1][1] = 0.003750;
        shifts_2[1][2] = 0.004500;
        shifts_2[1][3] = 0.006000;
        shifts_2[2][0] = 0.003000;
        shifts_2[2][1] = 0.003750;
        shifts_2[2][2] = 0.004500;
        shifts_2[2][3] = 0.006000;
        shifts_2[3][0] = 0.003000;
        shifts_2[3][1] = 0.003750;
        shifts_2[3][2] = 0.004500;
        shifts_2[3][3] = 0.006000;
 
        strikeSpreads[0] = -0.02;
        strikeSpreads[1] = -0.01;
        strikeSpreads[2] = 0.00;
        strikeSpreads[3] = +0.01;
        strikeSpreads[4] = +0.02;
        Size atmStrikeIndex = 2;
 
        // random smile
        MersenneTwisterUniformRng rng(42);
        Real nVolSpreadMin = 0.0010;
        Real nVolSpreadMax = 0.0050;
        Real lnVolSpreadMin = 0.1;
        Real lnVolSpreadMax = 0.3;
        Real slnVolSpreadMin = 0.05;
        Real slnVolSpreadMax = 0.25;
        for (Size i = 0; i < optionTenors.size(); ++i) {
            for (Size j = 0; j < swapTenors.size(); ++j) {
                for (Size k = 0; k < strikeSpreads.size(); ++k) {
                    Size index = j * optionTenors.size() + i;
                    Real nVolSpread =
                        k == atmStrikeIndex ? 0.0 : nVolSpreadMin + rng.nextReal() * (nVolSpreadMax - nVolSpreadMin);
                    nVolSpreads[index][k] = Handle<Quote>(QuantLib::ext::shared_ptr<SimpleQuote>(new SimpleQuote(nVolSpread)));
                    Real lnVolSpread =
                        k == atmStrikeIndex ? 0.0 : lnVolSpreadMin + rng.nextReal() * (lnVolSpreadMax - lnVolSpreadMin);
                    lnVolSpreads[index][k] =
                        Handle<Quote>(QuantLib::ext::shared_ptr<SimpleQuote>(new SimpleQuote(lnVolSpread)));
                    Real slnVolSpread = k == atmStrikeIndex
                                            ? 0.0
                                            : slnVolSpreadMin + rng.nextReal() * (slnVolSpreadMax - slnVolSpreadMin);
                    slnVolSpreads[index][k] =
                        Handle<Quote>(QuantLib::ext::shared_ptr<SimpleQuote>(new SimpleQuote(slnVolSpread)));
                }
            }
        }
    }

Member Data Documentation

optionTenors

vector<Period> optionTenors

Definition at line 206 of file swaptionmarketdata.hpp.

swapTenors

vector<Period> swapTenors

Definition at line 207 of file swaptionmarketdata.hpp.

strikeSpreads

vector<Real> strikeSpreads

Definition at line 208 of file swaptionmarketdata.hpp.

nVols

Matrix nVols

Definition at line 209 of file swaptionmarketdata.hpp.

lnVols

Matrix lnVols

Definition at line 210 of file swaptionmarketdata.hpp.

slnVols_1

Matrix slnVols_1

Definition at line 211 of file swaptionmarketdata.hpp.

slnVols_2

Matrix slnVols_2

Definition at line 212 of file swaptionmarketdata.hpp.

shifts_1

Matrix shifts_1

Definition at line 213 of file swaptionmarketdata.hpp.

shifts_2

Matrix shifts_2

Definition at line 214 of file swaptionmarketdata.hpp.

nVolSpreads

vector<vector<Handle<Quote> > > nVolSpreads

Definition at line 216 of file swaptionmarketdata.hpp.

lnVolSpreads

vector<vector<Handle<Quote> > > lnVolSpreads

Definition at line 216 of file swaptionmarketdata.hpp.

slnVolSpreads

vector<vector<Handle<Quote> > > slnVolSpreads

Definition at line 216 of file swaptionmarketdata.hpp.