BasketLosses.cpp

This example shows how to model losses across correlated assets.

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2014 Jose Aparicio
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<quantlib-dev@lists.sf.net>. The license is also available online at
<http://quantlib.org/license.shtml>.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
#include <ql/qldefines.hpp>
#ifdef BOOST_MSVC
# include <ql/auto_link.hpp>
#endif
#include <ql/experimental/credit/gaussianlhplossmodel.hpp>
#include <ql/experimental/credit/constantlosslatentmodel.hpp>
#include <ql/experimental/credit/binomiallossmodel.hpp>
#include <ql/experimental/credit/randomdefaultlatentmodel.hpp>
#include <ql/experimental/credit/randomlosslatentmodel.hpp>
#include <ql/experimental/credit/spotlosslatentmodel.hpp>
#include <ql/experimental/credit/basecorrelationlossmodel.hpp>
#include <ql/termstructures/credit/flathazardrate.hpp>
#include <ql/time/daycounters/actual365fixed.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/currencies/europe.hpp>
#include <boost/assign/std/vector.hpp>
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
using namespace QuantLib;
using namespace boost::assign;
#if defined(QL_ENABLE_SESSIONS)
namespace QuantLib {
ThreadKey sessionId() { return 0; }
}
#endif
int main(int, char* []) {
try {
std::cout << std::endl;
Calendar calendar = TARGET();
Date todaysDate(19, March, 2014);
// must be a business day
todaysDate = calendar.adjust(todaysDate);
Settings::instance().evaluationDate() = todaysDate;
/* --------------------------------------------------------------
SET UP BASKET PORTFOLIO
-------------------------------------------------------------- */
// build curves and issuers into a basket of ten names
std::vector<Real> hazardRates;
hazardRates +=
// 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9;
0.001, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09;
// 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01;
std::vector<std::string> names;
for(Size i=0; i<hazardRates.size(); i++)
names.push_back(std::string("Acme") +
boost::lexical_cast<std::string>(i));
std::vector<Handle<DefaultProbabilityTermStructure> > defTS;
for(Size i=0; i<hazardRates.size(); i++) {
defTS.push_back(Handle<DefaultProbabilityTermStructure>(
ext::make_shared<FlatHazardRate>(0, TARGET(), hazardRates[i],
Actual365Fixed())));
defTS.back()->enableExtrapolation();
}
std::vector<Issuer> issuers;
for(Size i=0; i<hazardRates.size(); i++) {
std::vector<QuantLib::Issuer::key_curve_pair> curves(1,
std::make_pair(NorthAmericaCorpDefaultKey(
EURCurrency(), QuantLib::SeniorSec,
Period(), 1. // amount threshold
), defTS[i]));
issuers.push_back(Issuer(curves));
}
ext::shared_ptr<Pool> thePool = ext::make_shared<Pool>();
for(Size i=0; i<hazardRates.size(); i++)
thePool->add(names[i], issuers[i], NorthAmericaCorpDefaultKey(
EURCurrency(), QuantLib::SeniorSec, Period(), 1.));
std::vector<DefaultProbKey> defaultKeys(hazardRates.size(),
NorthAmericaCorpDefaultKey(EURCurrency(), SeniorSec, Period(), 1.));
ext::shared_ptr<Basket> theBskt = ext::make_shared<Basket>(
todaysDate,
names, std::vector<Real>(hazardRates.size(), 100.), thePool,
// 0.0, 0.78);
0.03, .06);
/* --------------------------------------------------------------
SET UP DEFAULT LOSS MODELS
-------------------------------------------------------------- */
std::vector<Real> recoveries(hazardRates.size(), 0.4);
Date calcDate(TARGET().advance(Settings::instance().evaluationDate(),
Period(60, Months)));
Real factorValue = 0.05;
std::vector<std::vector<Real> > fctrsWeights(hazardRates.size(),
std::vector<Real>(1, std::sqrt(factorValue)));
// --- LHP model --------------------------
#ifndef QL_PATCH_SOLARIS
ext::shared_ptr<DefaultLossModel> lmGLHP(
ext::make_shared<GaussianLHPLossModel>(
fctrsWeights[0][0] * fctrsWeights[0][0], recoveries));
theBskt->setLossModel(lmGLHP);
std::cout << "GLHP Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
// --- G Binomial model --------------------
ext::shared_ptr<GaussianConstantLossLM> ktLossLM(
ext::make_shared<GaussianConstantLossLM>(fctrsWeights,
recoveries, LatentModelIntegrationType::GaussianQuadrature,
GaussianCopulaPolicy::initTraits()));
ext::shared_ptr<DefaultLossModel> lmBinomial(
ext::make_shared<GaussianBinomialLossModel>(ktLossLM));
theBskt->setLossModel(lmBinomial);
std::cout << "Gaussian Binomial Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
#endif
// --- T Binomial model --------------------
TCopulaPolicy::initTraits initT;
initT.tOrders = std::vector<Integer>(2, 3);
ext::shared_ptr<TConstantLossLM> ktTLossLM(
ext::make_shared<TConstantLossLM>(fctrsWeights,
recoveries,
//LatentModelIntegrationType::GaussianQuadrature,
LatentModelIntegrationType::Trapezoid,
initT));
ext::shared_ptr<DefaultLossModel> lmTBinomial(
ext::make_shared<TBinomialLossModel>(ktTLossLM));
theBskt->setLossModel(lmTBinomial);
std::cout << "T Binomial Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
// --- G Inhomogeneous model ---------------
Size numSimulations = 100000;
#ifndef QL_PATCH_SOLARIS
ext::shared_ptr<GaussianConstantLossLM> gLM(
ext::make_shared<GaussianConstantLossLM>(fctrsWeights,
recoveries,
LatentModelIntegrationType::GaussianQuadrature,
// g++ requires this when using make_shared
GaussianCopulaPolicy::initTraits()));
Size numBuckets = 100;
ext::shared_ptr<DefaultLossModel> inhomogeneousLM(
ext::make_shared<IHGaussPoolLossModel>(gLM, numBuckets));
theBskt->setLossModel(inhomogeneousLM);
std::cout << "G Inhomogeneous Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
// --- G Random model ---------------------
// Gaussian random joint default model:
// Size numCoresUsed = 4;
// Sobol, many cores
ext::shared_ptr<DefaultLossModel> rdlmG(
ext::make_shared<RandomDefaultLM<GaussianCopulaPolicy,
RandomSequenceGenerator<
BoxMullerGaussianRng<MersenneTwisterUniformRng> > > >(gLM,
recoveries, numSimulations, 1.e-6, 2863311530UL));
//ext::shared_ptr<DefaultLossModel> rdlmG(
// ext::make_shared<RandomDefaultLM<GaussianCopulaPolicy> >(gLM,
// recoveries, numSimulations, 1.e-6, 2863311530));
theBskt->setLossModel(rdlmG);
std::cout << "Random G Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
#endif
// --- StudentT Random model ---------------------
// Sobol, many cores
ext::shared_ptr<DefaultLossModel> rdlmT(
ext::make_shared<RandomDefaultLM<TCopulaPolicy,
RandomSequenceGenerator<
PolarStudentTRng<MersenneTwisterUniformRng> > > >(ktTLossLM,
recoveries, numSimulations, 1.e-6, 2863311530UL));
//ext::shared_ptr<DefaultLossModel> rdlmT(
// ext::make_shared<RandomDefaultLM<TCopulaPolicy> >(ktTLossLM,
// recoveries, numSimulations, 1.e-6, 2863311530));
theBskt->setLossModel(rdlmT);
std::cout << "Random T Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
// Spot Loss latent model:
#ifndef QL_PATCH_SOLARIS
std::vector<std::vector<Real> > fctrsWeightsRR(2 * hazardRates.size(),
std::vector<Real>(1, std::sqrt(factorValue)));
Real modelA = 2.2;
ext::shared_ptr<GaussianSpotLossLM> sptLG(new GaussianSpotLossLM(
fctrsWeightsRR, recoveries, modelA,
LatentModelIntegrationType::GaussianQuadrature,
GaussianCopulaPolicy::initTraits()));
ext::shared_ptr<TSpotLossLM> sptLT(new TSpotLossLM(fctrsWeightsRR,
recoveries, modelA,
LatentModelIntegrationType::GaussianQuadrature, initT));
// --- G Random Loss model ---------------------
// Gaussian random joint default model:
// Sobol, many cores
ext::shared_ptr<DefaultLossModel> rdLlmG(
ext::make_shared<RandomLossLM<GaussianCopulaPolicy> >(sptLG,
numSimulations, 1.e-6, 2863311530UL));
theBskt->setLossModel(rdLlmG);
std::cout << "Random Loss G Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
// --- T Random Loss model ---------------------
// Gaussian random joint default model:
// Sobol, many cores
ext::shared_ptr<DefaultLossModel> rdLlmT(
ext::make_shared<RandomLossLM<TCopulaPolicy> >(sptLT,
numSimulations, 1.e-6, 2863311530UL));
theBskt->setLossModel(rdLlmT);
std::cout << "Random Loss T Expected 10-Yr Losses: " << std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
// Base Correlation model set up to test cocherence with base LHP model
std::vector<Period> bcTenors;
bcTenors.push_back(Period(1, Years));
bcTenors.push_back(Period(5, Years));
std::vector<Real> bcLossPercentages;
bcLossPercentages.push_back(0.03);
bcLossPercentages.push_back(0.12);
std::vector<std::vector<Handle<Quote> > > correls;
//
std::vector<Handle<Quote> > corr1Y;
// 3%
corr1Y.push_back(Handle<Quote>(ext::shared_ptr<Quote>(
new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0]))));
// 12%
corr1Y.push_back(Handle<Quote>(ext::shared_ptr<Quote>(
new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0]))));
correls.push_back(corr1Y);
std::vector<Handle<Quote> > corr2Y;
// 3%
corr2Y.push_back(Handle<Quote>(ext::shared_ptr<Quote>(
new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0]))));
// 12%
corr2Y.push_back(Handle<Quote>(ext::shared_ptr<Quote>(
new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0]))));
correls.push_back(corr2Y);
ext::shared_ptr<BaseCorrelationTermStructure<BilinearInterpolation> >
correlSurface(
new BaseCorrelationTermStructure<BilinearInterpolation>(
// first one would do, all should be the same.
defTS[0]->settlementDays(),
defTS[0]->calendar(),
Unadjusted,
bcTenors,
bcLossPercentages,
correls,
Actual365Fixed()
)
);
Handle<BaseCorrelationTermStructure<BilinearInterpolation> >
correlHandle(correlSurface);
ext::shared_ptr<DefaultLossModel> bcLMG_LHP_Bilin(
ext::make_shared<GaussianLHPFlatBCLM>(correlHandle, recoveries,
GaussianCopulaPolicy::initTraits()));
theBskt->setLossModel(bcLMG_LHP_Bilin);
std::cout << "Base Correlation GLHP Expected 10-Yr Losses: "
<< std::endl;
std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl;
#endif
return 0;
} catch (exception& e) {
cerr << e.what() << endl;
return 1;
} catch (...) {
cerr << "unknown error" << endl;
return 1;
}
}