void InflationCPICapFloorTest::cpicapfloorpricer() { CommonVars common; Real nominal = 1.0; boost::shared_ptr<CPICapFloorTermPriceSurface> cpiCFpriceSurf(new InterpolatedCPICapFloorTermPriceSurface <Bilinear>(nominal, common.baseZeroRate, common.observationLag, common.calendar, common.convention, common.dcZCIIS, common.hii, common.nominalUK, common.cStrikesUK, common.fStrikesUK, common.cfMaturitiesUK, *(common.cPriceUK), *(common.fPriceUK))); common.cpiCFsurfUK = cpiCFpriceSurf; // interpolation pricer first // N.B. no new instrument required but we do need a new pricer Date startDate = Settings::instance().evaluationDate(); Date maturity(startDate + Period(3,Years)); Calendar fixCalendar = UnitedKingdom(), payCalendar = UnitedKingdom(); BusinessDayConvention fixConvention(Unadjusted), payConvention(ModifiedFollowing); Rate strike(0.03); Real baseCPI = common.hii->fixing(fixCalendar.adjust(startDate-common.observationLag,fixConvention)); CPI::InterpolationType observationInterpolation = CPI::AsIndex; CPICapFloor aCap(Option::Call, nominal, startDate, // start date of contract (only) baseCPI, maturity, // this is pre-adjustment! fixCalendar, fixConvention, payCalendar, payConvention, strike, common.hii, common.observationLag, observationInterpolation); Handle<CPICapFloorTermPriceSurface> cpiCFsurfUKh(common.cpiCFsurfUK); boost::shared_ptr<PricingEngine>engine(new InterpolatingCPICapFloorEngine(cpiCFsurfUKh)); aCap.setPricingEngine(engine); Date d = common.cpiCFsurfUK->cpiOptionDateFromTenor(Period(3,Years)); Real cached = cpiCFsurfUKh->capPrice(d, strike); QL_REQUIRE(fabs(cached - aCap.NPV())<1e-10,"InterpolatingCPICapFloorEngine does not reproduce cached price: " << cached << " vs " << aCap.NPV()); // remove circular refernce common.hcpi.linkTo(boost::shared_ptr<ZeroInflationTermStructure>()); }
AverageBMALeg::operator Leg() const { QL_REQUIRE(!notionals_.empty(), "no notional given"); Leg cashflows; // the following is not always correct Calendar calendar = schedule_.calendar(); Date refStart, start, refEnd, end; Date paymentDate; Size n = schedule_.size()-1; for (Size i=0; i<n; ++i) { refStart = start = schedule_.date(i); refEnd = end = schedule_.date(i+1); paymentDate = calendar.adjust(end, paymentAdjustment_); if (i == 0 && schedule_.hasIsRegular() && !schedule_.isRegular(i+1) && schedule_.hasTenor()) refStart = calendar.adjust(end - schedule_.tenor(), paymentAdjustment_); if (i == n-1 && schedule_.hasIsRegular() && !schedule_.isRegular(i+1) && schedule_.hasTenor()) refEnd = calendar.adjust(start + schedule_.tenor(), paymentAdjustment_); cashflows.push_back(ext::shared_ptr<CashFlow>(new AverageBMACoupon(paymentDate, detail::get(notionals_, i, notionals_.back()), start, end, index_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0), refStart, refEnd, paymentDayCounter_))); } return cashflows; }
CmsSpreadRangeAccrualLeg::operator Leg() const { QL_REQUIRE(!notionals_.empty(), "no notional given"); Size n = schedule_.size()-1; QL_REQUIRE(notionals_.size() <= n, "too many nominals (" << notionals_.size() << "), only " << n << " required"); QL_REQUIRE(fixingDays_.size() <= n, "too many fixingDays (" << fixingDays_.size() << "), only " << n << " required"); QL_REQUIRE(gearings_.size()<=n, "too many gearings (" << gearings_.size() << "), only " << n << " required"); QL_REQUIRE(spreads_.size()<=n, "too many spreads (" << spreads_.size() << "), only " << n << " required"); QL_REQUIRE(lowerTriggers_.size()<=n, "too many lowerTriggers (" << lowerTriggers_.size() << "), only " << n << " required"); QL_REQUIRE(upperTriggers_.size()<=n, "too many upperTriggers (" << upperTriggers_.size() << "), only " << n << " required"); Leg leg(n); // the following is not always correct Calendar calendar = schedule_.calendar(); Date refStart, start, refEnd, end; Date paymentDate; std::vector<boost::shared_ptr<Schedule> > observationsSchedules; for (Size i=0; i<n; ++i) { refStart = start = schedule_.date(i); refEnd = end = schedule_.date(i+1); paymentDate = calendar.adjust(end, paymentAdjustment_); if (i==0 && !schedule_.isRegular(i+1)) { BusinessDayConvention bdc = schedule_.businessDayConvention(); refStart = calendar.adjust(end - schedule_.tenor(), bdc); } if (i==n-1 && !schedule_.isRegular(i+1)) { BusinessDayConvention bdc = schedule_.businessDayConvention(); refEnd = calendar.adjust(start + schedule_.tenor(), bdc); } if (detail::get(gearings_, i, 1.0) == 0.0) { // fixed coupon leg.push_back(boost::shared_ptr<CashFlow>(new FixedRateCoupon(paymentDate, detail::get(notionals_, i, Null<Real>()), detail::get(spreads_, i, 0.0), paymentDayCounter_, start, end, refStart, refEnd))); } else { // floating coupon observationsSchedules.push_back( boost::shared_ptr<Schedule>(new Schedule(start, end, observationTenor_, calendar, observationConvention_, observationConvention_, DateGeneration::Forward, false))); leg.push_back(boost::shared_ptr<CashFlow>(new CmsSpreadRangeAccrualCoupon( paymentDate, detail::get(notionals_, i, Null<Real>()), index_, start, end, detail::get(fixingDays_, i, 2), paymentDayCounter_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0), refStart, refEnd, observationsSchedules.back(), detail::get(lowerTriggers_, i, Null<Rate>()), detail::get(upperTriggers_, i, Null<Rate>())))); } } return leg; }
yoyInflationLeg::operator Leg() const { Size n = schedule_.size()-1; QL_REQUIRE(!notionals_.empty(), "no notional given"); QL_REQUIRE(notionals_.size() <= n, "too many nominals (" << notionals_.size() << "), only " << n << " required"); QL_REQUIRE(gearings_.size()<=n, "too many gearings (" << gearings_.size() << "), only " << n << " required"); QL_REQUIRE(spreads_.size()<=n, "too many spreads (" << spreads_.size() << "), only " << n << " required"); QL_REQUIRE(caps_.size()<=n, "too many caps (" << caps_.size() << "), only " << n << " required"); QL_REQUIRE(floors_.size()<=n, "too many floors (" << floors_.size() << "), only " << n << " required"); Leg leg; leg.reserve(n); Calendar calendar = paymentCalendar_; Date refStart, start, refEnd, end; for (Size i=0; i<n; ++i) { refStart = start = schedule_.date(i); refEnd = end = schedule_.date(i+1); Date paymentDate = calendar.adjust(end, paymentAdjustment_); if (i==0 && schedule_.hasIsRegular() && !schedule_.isRegular(i+1)) { BusinessDayConvention bdc = schedule_.businessDayConvention(); refStart = schedule_.calendar().adjust(end - schedule_.tenor(), bdc); } if (i==n-1 && schedule_.hasIsRegular() && !schedule_.isRegular(i+1)) { BusinessDayConvention bdc = schedule_.businessDayConvention(); refEnd = schedule_.calendar().adjust(start + schedule_.tenor(), bdc); } if (detail::get(gearings_, i, 1.0) == 0.0) { // fixed coupon leg.push_back(ext::shared_ptr<CashFlow>(new FixedRateCoupon(paymentDate, detail::get(notionals_, i, 1.0), detail::effectiveFixedRate(spreads_,caps_, floors_,i), paymentDayCounter_, start, end, refStart, refEnd))); } else { // yoy inflation coupon if (detail::noOption(caps_, floors_, i)) { // just swaplet ext::shared_ptr<YoYInflationCoupon> coup(new YoYInflationCoupon( paymentDate, detail::get(notionals_, i, 1.0), start, end, detail::get(fixingDays_, i, 0), index_, observationLag_, paymentDayCounter_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0), refStart, refEnd)); // in this case you can set a pricer // straight away because it only provides computation - not data ext::shared_ptr<YoYInflationCouponPricer> pricer( new YoYInflationCouponPricer); coup->setPricer(pricer); leg.push_back(ext::dynamic_pointer_cast<CashFlow>(coup)); } else { // cap/floorlet leg.push_back(ext::shared_ptr<CashFlow>(new CappedFlooredYoYInflationCoupon( paymentDate, detail::get(notionals_, i, 1.0), start, end, detail::get(fixingDays_, i, 0), index_, observationLag_, paymentDayCounter_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0), detail::get(caps_, i, Null<Rate>()), detail::get(floors_, i, Null<Rate>()), refStart, refEnd))); } } } return leg; }
int main(int, char* []) { try { boost::timer timer; 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>( boost::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)); } boost::shared_ptr<Pool> thePool = boost::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.)); boost::shared_ptr<Basket> theBskt = boost::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 -------------------------- boost::shared_ptr<DefaultLossModel> lmGLHP( boost::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 -------------------- boost::shared_ptr<GaussianConstantLossLM> ktLossLM( boost::make_shared<GaussianConstantLossLM>(fctrsWeights, recoveries, LatentModelIntegrationType::GaussianQuadrature, GaussianCopulaPolicy::initTraits())); boost::shared_ptr<DefaultLossModel> lmBinomial( boost::make_shared<GaussianBinomialLossModel>(ktLossLM)); theBskt->setLossModel(lmBinomial); std::cout << "Gaussian Binomial Expected 10-Yr Losses: " << std::endl; std::cout << theBskt->expectedTrancheLoss(calcDate) << std::endl; // --- T Binomial model -------------------- TCopulaPolicy::initTraits initT; initT.tOrders = std::vector<Integer>(2, 3); boost::shared_ptr<TConstantLossLM> ktTLossLM( boost::make_shared<TConstantLossLM>(fctrsWeights, recoveries, //LatentModelIntegrationType::GaussianQuadrature, LatentModelIntegrationType::Trapezoid, initT)); boost::shared_ptr<DefaultLossModel> lmTBinomial( boost::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 --------------- boost::shared_ptr<GaussianConstantLossLM> gLM( boost::make_shared<GaussianConstantLossLM>(fctrsWeights, recoveries, LatentModelIntegrationType::GaussianQuadrature, // g++ requires this when using make_shared GaussianCopulaPolicy::initTraits())); Size numBuckets = 100; boost::shared_ptr<DefaultLossModel> inhomogeneousLM( boost::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 numSimulations = 100000; // Size numCoresUsed = 4; // Sobol, many cores boost::shared_ptr<DefaultLossModel> rdlmG( boost::make_shared<RandomDefaultLM<GaussianCopulaPolicy, RandomSequenceGenerator< BoxMullerGaussianRng<MersenneTwisterUniformRng> > > >(gLM, recoveries, numSimulations, 1.e-6, 2863311530)); //boost::shared_ptr<DefaultLossModel> rdlmG( // boost::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; // --- StudentT Random model --------------------- // Sobol, many cores boost::shared_ptr<DefaultLossModel> rdlmT( boost::make_shared<RandomDefaultLM<TCopulaPolicy, RandomSequenceGenerator< PolarStudentTRng<MersenneTwisterUniformRng> > > >(ktTLossLM, recoveries, numSimulations, 1.e-6, 2863311530)); //boost::shared_ptr<DefaultLossModel> rdlmT( // boost::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: std::vector<std::vector<Real> > fctrsWeightsRR(2 * hazardRates.size(), std::vector<Real>(1, std::sqrt(factorValue))); Real modelA = 2.2; boost::shared_ptr<GaussianSpotLossLM> sptLG(new GaussianSpotLossLM( fctrsWeightsRR, recoveries, modelA, LatentModelIntegrationType::GaussianQuadrature, GaussianCopulaPolicy::initTraits())); boost::shared_ptr<TSpotLossLM> sptLT(new TSpotLossLM(fctrsWeightsRR, recoveries, modelA, LatentModelIntegrationType::GaussianQuadrature, initT)); // --- G Random Loss model --------------------- // Gaussian random joint default model: // Sobol, many cores boost::shared_ptr<DefaultLossModel> rdLlmG( boost::make_shared<RandomLossLM<GaussianCopulaPolicy> >(sptLG, numSimulations, 1.e-6, 2863311530)); 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 boost::shared_ptr<DefaultLossModel> rdLlmT( boost::make_shared<RandomLossLM<TCopulaPolicy> >(sptLT, numSimulations, 1.e-6, 2863311530)); 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>(boost::shared_ptr<Quote>( new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0])))); // 12% corr1Y.push_back(Handle<Quote>(boost::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>(boost::shared_ptr<Quote>( new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0])))); // 12% corr2Y.push_back(Handle<Quote>(boost::shared_ptr<Quote>( new SimpleQuote(fctrsWeights[0][0] * fctrsWeights[0][0])))); correls.push_back(corr2Y); boost::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); boost::shared_ptr<DefaultLossModel> bcLMG_LHP_Bilin( boost::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; Real seconds = timer.elapsed(); Integer hours = Integer(seconds/3600); seconds -= hours * 3600; Integer minutes = Integer(seconds/60); seconds -= minutes * 60; cout << "Run completed in "; if (hours > 0) cout << hours << " h "; if (hours > 0 || minutes > 0) cout << minutes << " m "; cout << fixed << setprecision(0) << seconds << " s" << endl; return 0; } catch (exception& e) { cerr << e.what() << endl; return 1; } catch (...) { cerr << "unknown error" << endl; return 1; } }
void ShortRateModelTest::testSwaps() { BOOST_TEST_MESSAGE("Testing Hull-White swap pricing against known values..."); SavedSettings backup; IndexHistoryCleaner cleaner; Date today = Settings::instance().evaluationDate(); Calendar calendar = TARGET(); today = calendar.adjust(today); Settings::instance().evaluationDate() = today; Date settlement = calendar.advance(today,2,Days); Date dates[] = { settlement, calendar.advance(settlement,1,Weeks), calendar.advance(settlement,1,Months), calendar.advance(settlement,3,Months), calendar.advance(settlement,6,Months), calendar.advance(settlement,9,Months), calendar.advance(settlement,1,Years), calendar.advance(settlement,2,Years), calendar.advance(settlement,3,Years), calendar.advance(settlement,5,Years), calendar.advance(settlement,10,Years), calendar.advance(settlement,15,Years) }; DiscountFactor discounts[] = { 1.0, 0.999258, 0.996704, 0.990809, 0.981798, 0.972570, 0.963430, 0.929532, 0.889267, 0.803693, 0.596903, 0.433022 }; Handle<YieldTermStructure> termStructure( boost::shared_ptr<YieldTermStructure>( new DiscountCurve( std::vector<Date>(dates,dates+LENGTH(dates)), std::vector<DiscountFactor>(discounts, discounts+LENGTH(discounts)), Actual365Fixed()))); boost::shared_ptr<HullWhite> model(new HullWhite(termStructure)); Integer start[] = { -3, 0, 3 }; Integer length[] = { 2, 5, 10 }; Rate rates[] = { 0.02, 0.04, 0.06 }; boost::shared_ptr<IborIndex> euribor(new Euribor6M(termStructure)); boost::shared_ptr<PricingEngine> engine( new TreeVanillaSwapEngine(model,120)); #if defined(QL_USE_INDEXED_COUPON) Real tolerance = 4.0e-3; #else Real tolerance = 1.0e-8; #endif for (Size i=0; i<LENGTH(start); i++) { Date startDate = calendar.advance(settlement,start[i],Months); if (startDate < today) { Date fixingDate = calendar.advance(startDate,-2,Days); TimeSeries<Real> pastFixings; pastFixings[fixingDate] = 0.03; IndexManager::instance().setHistory(euribor->name(), pastFixings); } for (Size j=0; j<LENGTH(length); j++) { Date maturity = calendar.advance(startDate,length[i],Years); Schedule fixedSchedule(startDate, maturity, Period(Annual), calendar, Unadjusted, Unadjusted, DateGeneration::Forward, false); Schedule floatSchedule(startDate, maturity, Period(Semiannual), calendar, Following, Following, DateGeneration::Forward, false); for (Size k=0; k<LENGTH(rates); k++) { VanillaSwap swap(VanillaSwap::Payer, 1000000.0, fixedSchedule, rates[k], Thirty360(), floatSchedule, euribor, 0.0, Actual360()); swap.setPricingEngine(boost::shared_ptr<PricingEngine>( new DiscountingSwapEngine(termStructure))); Real expected = swap.NPV(); swap.setPricingEngine(engine); Real calculated = swap.NPV(); Real error = std::fabs((expected-calculated)/expected); if (error > tolerance) { BOOST_ERROR("Failed to reproduce swap NPV:" << QL_FIXED << std::setprecision(9) << "\n calculated: " << calculated << "\n expected: " << expected << QL_SCIENTIFIC << "\n rel. error: " << error); } } } } }
void CreditDefaultSwapTest::testFairUpfront() { BOOST_TEST_MESSAGE( "Testing fair-upfront calculation for credit-default swaps..."); SavedSettings backup; // Initialize curves Calendar calendar = TARGET(); Date today = calendar.adjust(Date::todaysDate()); Settings::instance().evaluationDate() = today; Handle<Quote> hazardRate = Handle<Quote>( ext::shared_ptr<Quote>(new SimpleQuote(0.01234))); RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve; probabilityCurve.linkTo( ext::shared_ptr<DefaultProbabilityTermStructure>( new FlatHazardRate(0, calendar, hazardRate, Actual360()))); RelinkableHandle<YieldTermStructure> discountCurve; discountCurve.linkTo(ext::shared_ptr<YieldTermStructure>( new FlatForward(today,0.06,Actual360()))); // Build the schedule Date issueDate = today; Date maturity = calendar.advance(issueDate, 10, Years); BusinessDayConvention convention = Following; Schedule schedule = MakeSchedule().from(issueDate) .to(maturity) .withFrequency(Quarterly) .withCalendar(calendar) .withTerminationDateConvention(convention) .withRule(DateGeneration::TwentiethIMM); // Build the CDS Rate fixedRate = 0.05; Rate upfront = 0.001; DayCounter dayCount = Actual360(); Real notional = 10000.0; Real recoveryRate = 0.4; ext::shared_ptr<PricingEngine> engine( new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve, true)); CreditDefaultSwap cds(Protection::Seller, notional, upfront, fixedRate, schedule, convention, dayCount, true, true); cds.setPricingEngine(engine); Rate fairUpfront = cds.fairUpfront(); CreditDefaultSwap fairCds(Protection::Seller, notional, fairUpfront, fixedRate, schedule, convention, dayCount, true, true); fairCds.setPricingEngine(engine); Real fairNPV = fairCds.NPV(); Real tolerance = 1e-10; if (std::fabs(fairNPV) > tolerance) BOOST_ERROR( "Failed to reproduce null NPV with calculated fair upfront\n" << " calculated upfront: " << io::rate(fairUpfront) << "\n" << " calculated NPV: " << fairNPV); // same with null upfront to begin with upfront = 0.0; CreditDefaultSwap cds2(Protection::Seller, notional, upfront, fixedRate, schedule, convention, dayCount, true, true); cds2.setPricingEngine(engine); fairUpfront = cds2.fairUpfront(); CreditDefaultSwap fairCds2(Protection::Seller, notional, fairUpfront, fixedRate, schedule, convention, dayCount, true, true); fairCds2.setPricingEngine(engine); fairNPV = fairCds2.NPV(); if (std::fabs(fairNPV) > tolerance) BOOST_ERROR( "Failed to reproduce null NPV with calculated fair upfront\n" << " calculated upfront: " << io::rate(fairUpfront) << "\n" << " calculated NPV: " << fairNPV); }
void InflationTest::testYYTermStructure() { BOOST_MESSAGE("Testing year-on-year inflation term structure..."); SavedSettings backup; // try the YY UK Calendar calendar = UnitedKingdom(); BusinessDayConvention bdc = ModifiedFollowing; Date evaluationDate(13, August, 2007); evaluationDate = calendar.adjust(evaluationDate); Settings::instance().evaluationDate() = evaluationDate; // fixing data Date from(1, January, 2005); Date to(13, August, 2007); Schedule rpiSchedule = MakeSchedule().from(from).to(to) .withTenor(1*Months) .withCalendar(UnitedKingdom()) .withConvention(ModifiedFollowing); Real fixData[] = { 189.9, 189.9, 189.6, 190.5, 191.6, 192.0, 192.2, 192.2, 192.6, 193.1, 193.3, 193.6, 194.1, 193.4, 194.2, 195.0, 196.5, 197.7, 198.5, 198.5, 199.2, 200.1, 200.4, 201.1, 202.7, 201.6, 203.1, 204.4, 205.4, 206.2, 207.3, -999.0, -999 }; RelinkableHandle<YoYInflationTermStructure> hy; bool interp = false; boost::shared_ptr<YYUKRPIr> iir(new YYUKRPIr(interp, hy)); for (Size i=0; i<rpiSchedule.size();i++) { iir->addFixing(rpiSchedule[i], fixData[i]); } boost::shared_ptr<YieldTermStructure> nominalTS = nominalTermStructure(); // now build the YoY inflation curve Datum yyData[] = { { Date(13, August, 2008), 2.95 }, { Date(13, August, 2009), 2.95 }, { Date(13, August, 2010), 2.93 }, { Date(15, August, 2011), 2.955 }, { Date(13, August, 2012), 2.945 }, { Date(13, August, 2013), 2.985 }, { Date(13, August, 2014), 3.01 }, { Date(13, August, 2015), 3.035 }, { Date(13, August, 2016), 3.055 }, // note that { Date(13, August, 2017), 3.075 }, // some dates will be on { Date(13, August, 2019), 3.105 }, // holidays but the payment { Date(15, August, 2022), 3.135 }, // calendar will roll them { Date(13, August, 2027), 3.155 }, { Date(13, August, 2032), 3.145 }, { Date(13, August, 2037), 3.145 } }; Period observationLag = Period(2,Months); DayCounter dc = Thirty360(); // now build the helpers ... std::vector<boost::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > > helpers = makeHelpers<YoYInflationTermStructure,YearOnYearInflationSwapHelper, YoYInflationIndex>(yyData, LENGTH(yyData), iir, observationLag, calendar, bdc, dc); Rate baseYYRate = yyData[0].rate/100.0; boost::shared_ptr<PiecewiseYoYInflationCurve<Linear> > pYYTS( new PiecewiseYoYInflationCurve<Linear>( evaluationDate, calendar, dc, observationLag, iir->frequency(),iir->interpolated(), baseYYRate, Handle<YieldTermStructure>(nominalTS), helpers)); pYYTS->recalculate(); // validation // yoy swaps should reprice to zero // yy rates should not equal yySwap rates Real eps = 0.000001; // usual swap engine Handle<YieldTermStructure> hTS(nominalTS); boost::shared_ptr<PricingEngine> sppe(new DiscountingSwapEngine(hTS)); // make sure that the index has the latest yoy term structure hy.linkTo(pYYTS); for (Size j = 1; j < LENGTH(yyData); j++) { from = nominalTS->referenceDate(); to = yyData[j].date; Schedule yoySchedule = MakeSchedule().from(from).to(to) .withConvention(Unadjusted) // fixed leg gets calendar from .withCalendar(calendar) // schedule .withTenor(1*Years) .backwards() ; YearOnYearInflationSwap yyS2(YearOnYearInflationSwap::Payer, 1000000.0, yoySchedule,//fixed schedule, but same as yoy yyData[j].rate/100.0, dc, yoySchedule, iir, observationLag, 0.0, //spread on index dc, UnitedKingdom()); yyS2.setPricingEngine(sppe); BOOST_CHECK_MESSAGE(fabs(yyS2.NPV())<eps,"fresh yoy swap NPV!=0 from TS " <<"swap quote for pt " << j << ", is " << yyData[j].rate/100.0 <<" vs YoY rate "<< pYYTS->yoyRate(yyData[j].date-observationLag) <<" at quote date "<<(yyData[j].date-observationLag) <<", NPV of a fresh yoy swap is " << yyS2.NPV() <<"\n fair rate " << yyS2.fairRate() <<" payment "<<yyS2.paymentConvention()); } Size jj=3; for (Size k = 0; k < 14; k++) { from = nominalTS->referenceDate() - k*Months; to = yyData[jj].date - k*Months; Schedule yoySchedule = MakeSchedule().from(from).to(to) .withConvention(Unadjusted) // fixed leg gets calendar from .withCalendar(calendar) // schedule .withTenor(1*Years) .backwards() ; YearOnYearInflationSwap yyS3(YearOnYearInflationSwap::Payer, 1000000.0, yoySchedule,//fixed schedule, but same as yoy yyData[jj].rate/100.0, dc, yoySchedule, iir, observationLag, 0.0, //spread on index dc, UnitedKingdom()); yyS3.setPricingEngine(sppe); BOOST_CHECK_MESSAGE(fabs(yyS3.NPV())< 20000.0, "unexpected size of aged YoY swap, aged " <<k<<" months: YY aged NPV = " << yyS3.NPV() <<", legs "<< yyS3.legNPV(0) << " and " << yyS3.legNPV(1) ); } }
int main(int, char* []) { try { boost::timer timer; std::cout << std::endl; /********************* *** MARKET DATA *** *********************/ Calendar calendar = TARGET(); Date todaysDate(15, May, 2007); // must be a business day todaysDate = calendar.adjust(todaysDate); Settings::instance().evaluationDate() = todaysDate; // dummy curve boost::shared_ptr<Quote> flatRate(new SimpleQuote(0.01)); Handle<YieldTermStructure> tsCurve( boost::shared_ptr<FlatForward>( new FlatForward(todaysDate, Handle<Quote>(flatRate), Actual365Fixed()))); /* In Lehmans Brothers "guide to exotic credit derivatives" p. 32 there's a simple case, zero flat curve with a flat CDS curve with constant market spreads of 150 bp and RR = 50% corresponds to a flat 3% hazard rate. The implied 1-year survival probability is 97.04% and the 2-years is 94.18% */ // market Real recovery_rate = 0.5; Real quoted_spreads[] = { 0.0150, 0.0150, 0.0150, 0.0150 }; vector<Period> tenors; tenors.push_back(3*Months); tenors.push_back(6*Months); tenors.push_back(1*Years); tenors.push_back(2*Years); vector<Date> maturities; for (Size i=0; i<4; i++) { maturities.push_back(calendar.adjust(todaysDate + tenors[i], Following)); } std::vector<boost::shared_ptr<DefaultProbabilityHelper> > instruments; for (Size i=0; i<4; i++) { instruments.push_back(boost::shared_ptr<DefaultProbabilityHelper>( new SpreadCdsHelper( Handle<Quote>(boost::shared_ptr<Quote>( new SimpleQuote(quoted_spreads[i]))), tenors[i], 0, calendar, Quarterly, Following, DateGeneration::TwentiethIMM, Actual365Fixed(), recovery_rate, tsCurve))); } // Bootstrap hazard rates boost::shared_ptr<PiecewiseDefaultCurve<HazardRate, BackwardFlat> > hazardRateStructure( new PiecewiseDefaultCurve<HazardRate, BackwardFlat>( todaysDate, instruments, Actual365Fixed())); vector<pair<Date, Real> > hr_curve_data = hazardRateStructure->nodes(); cout << "Calibrated hazard rate values: " << endl ; for (Size i=0; i<hr_curve_data.size(); i++) { cout << "hazard rate on " << hr_curve_data[i].first << " is " << hr_curve_data[i].second << endl; } cout << endl; cout << "Some survival probability values: " << endl ; cout << "1Y survival probability: " << io::percent(hazardRateStructure->survivalProbability( todaysDate + 1*Years)) << endl << " expected: " << io::percent(0.9704) << endl; cout << "2Y survival probability: " << io::percent(hazardRateStructure->survivalProbability( todaysDate + 2*Years)) << endl << " expected: " << io::percent(0.9418) << endl; cout << endl << endl; // reprice instruments Real nominal = 1000000.0; Handle<DefaultProbabilityTermStructure> probability(hazardRateStructure); boost::shared_ptr<PricingEngine> engine( new MidPointCdsEngine(probability, recovery_rate, tsCurve)); Schedule cdsSchedule = MakeSchedule().from(todaysDate).to(maturities[0]) .withFrequency(Quarterly) .withCalendar(calendar) .withTerminationDateConvention(Unadjusted) .withRule(DateGeneration::TwentiethIMM); CreditDefaultSwap cds_3m(Protection::Seller, nominal, quoted_spreads[0], cdsSchedule, Following, Actual365Fixed()); cdsSchedule = MakeSchedule().from(todaysDate).to(maturities[1]) .withFrequency(Quarterly) .withCalendar(calendar) .withTerminationDateConvention(Unadjusted) .withRule(DateGeneration::TwentiethIMM); CreditDefaultSwap cds_6m(Protection::Seller, nominal, quoted_spreads[1], cdsSchedule, Following, Actual365Fixed()); cdsSchedule = MakeSchedule().from(todaysDate).to(maturities[2]) .withFrequency(Quarterly) .withCalendar(calendar) .withTerminationDateConvention(Unadjusted) .withRule(DateGeneration::TwentiethIMM); CreditDefaultSwap cds_1y(Protection::Seller, nominal, quoted_spreads[2], cdsSchedule, Following, Actual365Fixed()); cdsSchedule = MakeSchedule().from(todaysDate).to(maturities[3]) .withFrequency(Quarterly) .withCalendar(calendar) .withTerminationDateConvention(Unadjusted) .withRule(DateGeneration::TwentiethIMM); CreditDefaultSwap cds_2y(Protection::Seller, nominal, quoted_spreads[3], cdsSchedule, Following, Actual365Fixed()); cds_3m.setPricingEngine(engine); cds_6m.setPricingEngine(engine); cds_1y.setPricingEngine(engine); cds_2y.setPricingEngine(engine); cout << "Repricing of quoted CDSs employed for calibration: " << endl; cout << "3M fair spread: " << io::rate(cds_3m.fairSpread()) << endl << " NPV: " << cds_3m.NPV() << endl << " default leg: " << cds_3m.defaultLegNPV() << endl << " coupon leg: " << cds_3m.couponLegNPV() << endl << endl; cout << "6M fair spread: " << io::rate(cds_6m.fairSpread()) << endl << " NPV: " << cds_6m.NPV() << endl << " default leg: " << cds_6m.defaultLegNPV() << endl << " coupon leg: " << cds_6m.couponLegNPV() << endl << endl; cout << "1Y fair spread: " << io::rate(cds_1y.fairSpread()) << endl << " NPV: " << cds_1y.NPV() << endl << " default leg: " << cds_1y.defaultLegNPV() << endl << " coupon leg: " << cds_1y.couponLegNPV() << endl << endl; cout << "2Y fair spread: " << io::rate(cds_2y.fairSpread()) << endl << " NPV: " << cds_2y.NPV() << endl << " default leg: " << cds_2y.defaultLegNPV() << endl << " coupon leg: " << cds_2y.couponLegNPV() << endl << endl; cout << endl << endl; Real seconds = timer.elapsed(); Integer hours = Integer(seconds/3600); seconds -= hours * 3600; Integer minutes = Integer(seconds/60); seconds -= minutes * 60; cout << "Run completed in "; if (hours > 0) cout << hours << " h "; if (hours > 0 || minutes > 0) cout << minutes << " m "; cout << fixed << setprecision(0) << seconds << " s" << endl; return 0; } catch (exception& e) { cerr << e.what() << endl; return 1; } catch (...) { cerr << "unknown error" << endl; return 1; } }
FixedRateLeg::operator Leg() const { QL_REQUIRE(!couponRates_.empty(), "no coupon rates given"); QL_REQUIRE(!notionals_.empty(), "no notional given"); Leg leg; leg.reserve(schedule_.size()-1); Calendar schCalendar = schedule_.calendar(); // first period might be short or long Date start = schedule_.date(0), end = schedule_.date(1); Date paymentDate = calendar_.adjust(end, paymentAdjustment_); Date exCouponDate; InterestRate rate = couponRates_[0]; Real nominal = notionals_[0]; if (exCouponPeriod_ != Period()) { exCouponDate = exCouponCalendar_.advance(paymentDate, -exCouponPeriod_, exCouponAdjustment_, exCouponEndOfMonth_); } if (schedule_.isRegular(1)) { QL_REQUIRE(firstPeriodDC_.empty() || firstPeriodDC_ == rate.dayCounter(), "regular first coupon " "does not allow a first-period day count"); shared_ptr<CashFlow> temp(new FixedRateCoupon(paymentDate, nominal, rate, start, end, start, end, exCouponDate)); leg.push_back(temp); } else { Date ref = end - schedule_.tenor(); ref = schCalendar.adjust(ref, schedule_.businessDayConvention()); InterestRate r(rate.rate(), firstPeriodDC_.empty() ? rate.dayCounter() : firstPeriodDC_, rate.compounding(), rate.frequency()); leg.push_back(shared_ptr<CashFlow>(new FixedRateCoupon(paymentDate, nominal, r, start, end, ref, end, exCouponDate))); } // regular periods for (Size i=2; i<schedule_.size()-1; ++i) { start = end; end = schedule_.date(i); paymentDate = calendar_.adjust(end, paymentAdjustment_); if (exCouponPeriod_ != Period()) { exCouponDate = exCouponCalendar_.advance(paymentDate, -exCouponPeriod_, exCouponAdjustment_, exCouponEndOfMonth_); } if ((i-1) < couponRates_.size()) rate = couponRates_[i-1]; else rate = couponRates_.back(); if ((i-1) < notionals_.size()) nominal = notionals_[i-1]; else nominal = notionals_.back(); leg.push_back(shared_ptr<CashFlow>(new FixedRateCoupon(paymentDate, nominal, rate, start, end, start, end, exCouponDate))); } if (schedule_.size() > 2) { // last period might be short or long Size N = schedule_.size(); start = end; end = schedule_.date(N-1); paymentDate = calendar_.adjust(end, paymentAdjustment_); if (exCouponPeriod_ != Period()) { exCouponDate = exCouponCalendar_.advance(paymentDate, -exCouponPeriod_, exCouponAdjustment_, exCouponEndOfMonth_); } if ((N-2) < couponRates_.size()) rate = couponRates_[N-2]; else rate = couponRates_.back(); if ((N-2) < notionals_.size()) nominal = notionals_[N-2]; else nominal = notionals_.back(); InterestRate r(rate.rate(), lastPeriodDC_.empty() ? rate.dayCounter() : lastPeriodDC_, rate.compounding(), rate.frequency()); if (schedule_.isRegular(N - 1)) { leg.push_back(shared_ptr<CashFlow>(new FixedRateCoupon(paymentDate, nominal, r, start, end, start, end, exCouponDate))); } else { Date ref = start + schedule_.tenor(); ref = schCalendar.adjust(ref, schedule_.businessDayConvention()); leg.push_back(shared_ptr<CashFlow>(new FixedRateCoupon(paymentDate, nominal, r, start, end, start, ref, exCouponDate))); } } return leg; }
int main(int, char* []) { try { boost::timer timer; std::cout << std::endl; /********************* *** MARKET DATA *** *********************/ Calendar calendar = TARGET(); Date settlementDate(18, September, 2008); // must be a business day settlementDate = calendar.adjust(settlementDate); Integer fixingDays = 3; Natural settlementDays = 3; Date todaysDate = calendar.advance(settlementDate, -fixingDays, Days); // nothing to do with Date::todaysDate Settings::instance().evaluationDate() = todaysDate; std::cout << "Today: " << todaysDate.weekday() << ", " << todaysDate << std::endl; std::cout << "Settlement date: " << settlementDate.weekday() << ", " << settlementDate << std::endl; // Building of the bonds discounting yield curve /********************* *** RATE HELPERS *** *********************/ // RateHelpers are built from the above quotes together with // other instrument dependant infos. Quotes are passed in // relinkable handles which could be relinked to some other // data source later. // Common data // ZC rates for the short end Rate zc3mQuote=0.0096; Rate zc6mQuote=0.0145; Rate zc1yQuote=0.0194; boost::shared_ptr<Quote> zc3mRate(new SimpleQuote(zc3mQuote)); boost::shared_ptr<Quote> zc6mRate(new SimpleQuote(zc6mQuote)); boost::shared_ptr<Quote> zc1yRate(new SimpleQuote(zc1yQuote)); DayCounter zcBondsDayCounter = Actual365Fixed(); boost::shared_ptr<RateHelper> zc3m(new DepositRateHelper( Handle<Quote>(zc3mRate), 3*Months, fixingDays, calendar, ModifiedFollowing, true, zcBondsDayCounter)); boost::shared_ptr<RateHelper> zc6m(new DepositRateHelper( Handle<Quote>(zc6mRate), 6*Months, fixingDays, calendar, ModifiedFollowing, true, zcBondsDayCounter)); boost::shared_ptr<RateHelper> zc1y(new DepositRateHelper( Handle<Quote>(zc1yRate), 1*Years, fixingDays, calendar, ModifiedFollowing, true, zcBondsDayCounter)); // setup bonds Real redemption = 100.0; const Size numberOfBonds = 5; Date issueDates[] = { Date (15, March, 2005), Date (15, June, 2005), Date (30, June, 2006), Date (15, November, 2002), Date (15, May, 1987) }; Date maturities[] = { Date (31, August, 2010), Date (31, August, 2011), Date (31, August, 2013), Date (15, August, 2018), Date (15, May, 2038) }; Real couponRates[] = { 0.02375, 0.04625, 0.03125, 0.04000, 0.04500 }; Real marketQuotes[] = { 100.390625, 106.21875, 100.59375, 101.6875, 102.140625 }; std::vector< boost::shared_ptr<SimpleQuote> > quote; for (Size i=0; i<numberOfBonds; i++) { boost::shared_ptr<SimpleQuote> cp(new SimpleQuote(marketQuotes[i])); quote.push_back(cp); } RelinkableHandle<Quote> quoteHandle[numberOfBonds]; for (Size i=0; i<numberOfBonds; i++) { quoteHandle[i].linkTo(quote[i]); } // Definition of the rate helpers std::vector<boost::shared_ptr<BondHelper> > bondsHelpers; for (Size i=0; i<numberOfBonds; i++) { Schedule schedule(issueDates[i], maturities[i], Period(Semiannual), UnitedStates(UnitedStates::GovernmentBond), Unadjusted, Unadjusted, DateGeneration::Backward, false); boost::shared_ptr<FixedRateBondHelper> bondHelper(new FixedRateBondHelper( quoteHandle[i], settlementDays, 100.0, schedule, std::vector<Rate>(1,couponRates[i]), ActualActual(ActualActual::Bond), Unadjusted, redemption, issueDates[i])); // the above could also be done by creating a // FixedRateBond instance and writing: // // boost::shared_ptr<BondHelper> bondHelper( // new BondHelper(quoteHandle[i], bond)); // // This would also work for bonds that still don't have a // specialized helper, such as floating-rate bonds. bondsHelpers.push_back(bondHelper); } /********************* ** CURVE BUILDING ** *********************/ // Any DayCounter would be fine. // ActualActual::ISDA ensures that 30 years is 30.0 DayCounter termStructureDayCounter = ActualActual(ActualActual::ISDA); double tolerance = 1.0e-15; // A depo-bond curve std::vector<boost::shared_ptr<RateHelper> > bondInstruments; // Adding the ZC bonds to the curve for the short end bondInstruments.push_back(zc3m); bondInstruments.push_back(zc6m); bondInstruments.push_back(zc1y); // Adding the Fixed rate bonds to the curve for the long end for (Size i=0; i<numberOfBonds; i++) { bondInstruments.push_back(bondsHelpers[i]); } boost::shared_ptr<YieldTermStructure> bondDiscountingTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, bondInstruments, termStructureDayCounter, tolerance)); // Building of the Libor forecasting curve // deposits Rate d1wQuote=0.043375; Rate d1mQuote=0.031875; Rate d3mQuote=0.0320375; Rate d6mQuote=0.03385; Rate d9mQuote=0.0338125; Rate d1yQuote=0.0335125; // swaps Rate s2yQuote=0.0295; Rate s3yQuote=0.0323; Rate s5yQuote=0.0359; Rate s10yQuote=0.0412; Rate s15yQuote=0.0433; /******************** *** QUOTES *** ********************/ // SimpleQuote stores a value which can be manually changed; // other Quote subclasses could read the value from a database // or some kind of data feed. // deposits boost::shared_ptr<Quote> d1wRate(new SimpleQuote(d1wQuote)); boost::shared_ptr<Quote> d1mRate(new SimpleQuote(d1mQuote)); boost::shared_ptr<Quote> d3mRate(new SimpleQuote(d3mQuote)); boost::shared_ptr<Quote> d6mRate(new SimpleQuote(d6mQuote)); boost::shared_ptr<Quote> d9mRate(new SimpleQuote(d9mQuote)); boost::shared_ptr<Quote> d1yRate(new SimpleQuote(d1yQuote)); // swaps boost::shared_ptr<Quote> s2yRate(new SimpleQuote(s2yQuote)); boost::shared_ptr<Quote> s3yRate(new SimpleQuote(s3yQuote)); boost::shared_ptr<Quote> s5yRate(new SimpleQuote(s5yQuote)); boost::shared_ptr<Quote> s10yRate(new SimpleQuote(s10yQuote)); boost::shared_ptr<Quote> s15yRate(new SimpleQuote(s15yQuote)); /********************* *** RATE HELPERS *** *********************/ // RateHelpers are built from the above quotes together with // other instrument dependant infos. Quotes are passed in // relinkable handles which could be relinked to some other // data source later. // deposits DayCounter depositDayCounter = Actual360(); boost::shared_ptr<RateHelper> d1w(new DepositRateHelper( Handle<Quote>(d1wRate), 1*Weeks, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1m(new DepositRateHelper( Handle<Quote>(d1mRate), 1*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d3m(new DepositRateHelper( Handle<Quote>(d3mRate), 3*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d6m(new DepositRateHelper( Handle<Quote>(d6mRate), 6*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d9m(new DepositRateHelper( Handle<Quote>(d9mRate), 9*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1y(new DepositRateHelper( Handle<Quote>(d1yRate), 1*Years, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); // setup swaps Frequency swFixedLegFrequency = Annual; BusinessDayConvention swFixedLegConvention = Unadjusted; DayCounter swFixedLegDayCounter = Thirty360(Thirty360::European); boost::shared_ptr<IborIndex> swFloatingLegIndex(new Euribor6M); const Period forwardStart(1*Days); boost::shared_ptr<RateHelper> s2y(new SwapRateHelper( Handle<Quote>(s2yRate), 2*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex, Handle<Quote>(),forwardStart)); boost::shared_ptr<RateHelper> s3y(new SwapRateHelper( Handle<Quote>(s3yRate), 3*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex, Handle<Quote>(),forwardStart)); boost::shared_ptr<RateHelper> s5y(new SwapRateHelper( Handle<Quote>(s5yRate), 5*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex, Handle<Quote>(),forwardStart)); boost::shared_ptr<RateHelper> s10y(new SwapRateHelper( Handle<Quote>(s10yRate), 10*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex, Handle<Quote>(),forwardStart)); boost::shared_ptr<RateHelper> s15y(new SwapRateHelper( Handle<Quote>(s15yRate), 15*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex, Handle<Quote>(),forwardStart)); /********************* ** CURVE BUILDING ** *********************/ // Any DayCounter would be fine. // ActualActual::ISDA ensures that 30 years is 30.0 // A depo-swap curve std::vector<boost::shared_ptr<RateHelper> > depoSwapInstruments; depoSwapInstruments.push_back(d1w); depoSwapInstruments.push_back(d1m); depoSwapInstruments.push_back(d3m); depoSwapInstruments.push_back(d6m); depoSwapInstruments.push_back(d9m); depoSwapInstruments.push_back(d1y); depoSwapInstruments.push_back(s2y); depoSwapInstruments.push_back(s3y); depoSwapInstruments.push_back(s5y); depoSwapInstruments.push_back(s10y); depoSwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoSwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoSwapInstruments, termStructureDayCounter, tolerance)); // Term structures that will be used for pricing: // the one used for discounting cash flows RelinkableHandle<YieldTermStructure> discountingTermStructure; // the one used for forward rate forecasting RelinkableHandle<YieldTermStructure> forecastingTermStructure; /********************* * BONDS TO BE PRICED * **********************/ // Common data Real faceAmount = 100; // Pricing engine boost::shared_ptr<PricingEngine> bondEngine( new DiscountingBondEngine(discountingTermStructure)); // Zero coupon bond ZeroCouponBond zeroCouponBond( settlementDays, UnitedStates(UnitedStates::GovernmentBond), faceAmount, Date(15,August,2013), Following, Real(116.92), Date(15,August,2003)); zeroCouponBond.setPricingEngine(bondEngine); // Fixed 4.5% US Treasury Note Schedule fixedBondSchedule(Date(15, May, 2007), Date(15,May,2017), Period(Semiannual), UnitedStates(UnitedStates::GovernmentBond), Unadjusted, Unadjusted, DateGeneration::Backward, false); FixedRateBond fixedRateBond( settlementDays, faceAmount, fixedBondSchedule, std::vector<Rate>(1, 0.045), ActualActual(ActualActual::Bond), ModifiedFollowing, 100.0, Date(15, May, 2007)); fixedRateBond.setPricingEngine(bondEngine); // Floating rate bond (3M USD Libor + 0.1%) // Should and will be priced on another curve later... RelinkableHandle<YieldTermStructure> liborTermStructure; const boost::shared_ptr<IborIndex> libor3m( new USDLibor(Period(3,Months),liborTermStructure)); libor3m->addFixing(Date(17, July, 2008),0.0278625); Schedule floatingBondSchedule(Date(21, October, 2005), Date(21, October, 2010), Period(Quarterly), UnitedStates(UnitedStates::NYSE), Unadjusted, Unadjusted, DateGeneration::Backward, true); FloatingRateBond floatingRateBond( settlementDays, faceAmount, floatingBondSchedule, libor3m, Actual360(), ModifiedFollowing, Natural(2), // Gearings std::vector<Real>(1, 1.0), // Spreads std::vector<Rate>(1, 0.001), // Caps std::vector<Rate>(), // Floors std::vector<Rate>(), // Fixing in arrears true, Real(100.0), Date(21, October, 2005)); floatingRateBond.setPricingEngine(bondEngine); // Coupon pricers boost::shared_ptr<IborCouponPricer> pricer(new BlackIborCouponPricer); // optionLet volatilities Volatility volatility = 0.0; Handle<OptionletVolatilityStructure> vol; vol = Handle<OptionletVolatilityStructure>( boost::shared_ptr<OptionletVolatilityStructure>(new ConstantOptionletVolatility( settlementDays, calendar, ModifiedFollowing, volatility, Actual365Fixed()))); pricer->setCapletVolatility(vol); setCouponPricer(floatingRateBond.cashflows(),pricer); // Yield curve bootstrapping forecastingTermStructure.linkTo(depoSwapTermStructure); discountingTermStructure.linkTo(bondDiscountingTermStructure); // We are using the depo & swap curve to estimate the future Libor rates liborTermStructure.linkTo(depoSwapTermStructure); /*************** * BOND PRICING * ****************/ std::cout << std::endl; // write column headings Size widths[] = { 18, 10, 10, 10 }; std::cout << std::setw(widths[0]) << " " << std::setw(widths[1]) << "ZC" << std::setw(widths[2]) << "Fixed" << std::setw(widths[3]) << "Floating" << std::endl; std::string separator = " | "; Size width = widths[0] + widths[1] + widths[2] + widths[3]; std::string rule(width, '-'), dblrule(width, '='); std::string tab(8, ' '); std::cout << rule << std::endl; std::cout << std::fixed; std::cout << std::setprecision(2); std::cout << std::setw(widths[0]) << "Net present value" << std::setw(widths[1]) << zeroCouponBond.NPV() << std::setw(widths[2]) << fixedRateBond.NPV() << std::setw(widths[3]) << floatingRateBond.NPV() << std::endl; std::cout << std::setw(widths[0]) << "Clean price" << std::setw(widths[1]) << zeroCouponBond.cleanPrice() << std::setw(widths[2]) << fixedRateBond.cleanPrice() << std::setw(widths[3]) << floatingRateBond.cleanPrice() << std::endl; std::cout << std::setw(widths[0]) << "Dirty price" << std::setw(widths[1]) << zeroCouponBond.dirtyPrice() << std::setw(widths[2]) << fixedRateBond.dirtyPrice() << std::setw(widths[3]) << floatingRateBond.dirtyPrice() << std::endl; std::cout << std::setw(widths[0]) << "Accrued coupon" << std::setw(widths[1]) << zeroCouponBond.accruedAmount() << std::setw(widths[2]) << fixedRateBond.accruedAmount() << std::setw(widths[3]) << floatingRateBond.accruedAmount() << std::endl; std::cout << std::setw(widths[0]) << "Previous coupon" << std::setw(widths[1]) << "N/A" // zeroCouponBond << std::setw(widths[2]) << io::rate(fixedRateBond.previousCouponRate()) << std::setw(widths[3]) << io::rate(floatingRateBond.previousCouponRate()) << std::endl; std::cout << std::setw(widths[0]) << "Next coupon" << std::setw(widths[1]) << "N/A" // zeroCouponBond << std::setw(widths[2]) << io::rate(fixedRateBond.nextCouponRate()) << std::setw(widths[3]) << io::rate(floatingRateBond.nextCouponRate()) << std::endl; std::cout << std::setw(widths[0]) << "Yield" << std::setw(widths[1]) << io::rate(zeroCouponBond.yield(Actual360(),Compounded,Annual)) << std::setw(widths[2]) << io::rate(fixedRateBond.yield(Actual360(),Compounded,Annual)) << std::setw(widths[3]) << io::rate(floatingRateBond.yield(Actual360(),Compounded,Annual)) << std::endl; std::cout << std::endl; // Other computations std::cout << "Sample indirect computations (for the floating rate bond): " << std::endl; std::cout << rule << std::endl; std::cout << "Yield to Clean Price: " << floatingRateBond.cleanPrice(floatingRateBond.yield(Actual360(),Compounded,Annual),Actual360(),Compounded,Annual,settlementDate) << std::endl; std::cout << "Clean Price to Yield: " << io::rate(floatingRateBond.yield(floatingRateBond.cleanPrice(),Actual360(),Compounded,Annual,settlementDate)) << std::endl; /* "Yield to Price" "Price to Yield" */ double seconds = timer.elapsed(); Integer hours = int(seconds/3600); seconds -= hours * 3600; Integer minutes = int(seconds/60); seconds -= minutes * 60; std::cout << " \nRun completed in "; if (hours > 0) std::cout << hours << " h "; if (hours > 0 || minutes > 0) std::cout << minutes << " m "; std::cout << std::fixed << std::setprecision(0) << seconds << " s\n" << std::endl; return 0; } catch (std::exception& e) { std::cerr << e.what() << std::endl; return 1; } catch (...) { std::cerr << "unknown error" << std::endl; return 1; } }
void qlHazardRateFactory::calculate() { try { TiXmlDocument document; document.Parse(instInfo_.c_str(), 0, TIXML_ENCODING_UTF8); TiXmlNode* rootNode = document.FirstChild("defaultCurveCalculation"); Settings::instance().evaluationDate() = strToDate(rootNode->FirstChildElement("evaluationTime")->GetText()); DayCounter daycounter = Actual365Fixed(); TiXmlElement* pricingParametorNode = rootNode->FirstChildElement("pricingParameter"); TiXmlElement* referenceCurveNode = pricingParametorNode->FirstChildElement("referenceCurves"); Calendar calendar = SouthKorea(); Date refereceDate = Settings::instance().evaluationDate(); // must be a business day refereceDate = calendar.adjust(refereceDate); // dummy curve boost::shared_ptr<Quote> flatRate(new SimpleQuote(0.01)); //Handle<YieldTermStructure> tsCurve( // boost::shared_ptr<FlatForward>( // new FlatForward(todaysDate, Handle<Quote>(flatRate), // Actual365Fixed()))); TiXmlNode* pricingParametorNode = document.FirstChild("pricingParameter"); TiXmlElement* referenceCurveNode = pricingParametorNode->FirstChildElement("referenceCurves"); std::vector<boost::shared_ptr<HazardRateStructure>> hazardRateCurves; TiXmlElement* tsNode = referenceCurveNode->FirstChildElement("termstructure"); if(tsNode) { for(tsNode; tsNode; tsNode = tsNode->NextSiblingElement("termstructure")) { hazardRateCurves.push_back(this->hazardRateTS(tsNode)); } } TiXmlNode* yieldNode = document.FirstChild("yieldNode"); qlYieldTermStructureFactory yieldTsFactory = qlYieldTermStructureFactory(); this->tsCurve_ = yieldTsFactory.yieldTSHandle(yieldNode); // outputTenor Build std::vector<Period> outputTenors; Size outputNum = outputTenors.size(); qlTimeUnitFactory tuFactory = qlTimeUnitFactory(); TiXmlElement* outputTenorNode = pricingParametorNode->FirstChildElement("outputCurveTemplate"); TiXmlElement* tenorNode = outputTenorNode->FirstChildElement("tenorList"); if(tenorNode) { for(tenorNode; tenorNode; tenorNode = tenorNode->NextSiblingElement("tenor")) { outputTenors.push_back(tuFactory.timeUnit(tenorNode)); } } //compositeCalculation boost::shared_ptr<DefaultProbabilityTermStructure> copulaHazardTS = boost::shared_ptr<DefaultProbabilityTermStructure>(new CopulaHazardRate<ProbabilityOfAtLeastNEvents,Linear>( dates,hazardRateCurves,0.9,1,50)); //result for (Size i=0 ; i<outputNum ; ++i) { dates_.push_back(calendar.advance(refereceDate,outputTenors[i])); dateTimes_.push_back(daycounter.yearFraction(refereceDate,dates_[i])); data_.push_back(copulaHazardTS->defaultProbability(dateTimes_[i])); } // makeXml this->buildResultXml(); //this->buildResultXml(inst_->additionalResults()); } catch (std::exception& e) { std::cerr << e.what() << std::endl; } catch (...) { std::cerr << "unknown error" << std::endl; } }
PiecewiseYieldCurve<Discount, LogLinear>* create_yield_curve() { Calendar calendar = UnitedStates(); Date settlementDate(4, January, 2012); // must be a business day settlementDate = calendar.adjust(settlementDate); Integer fixingDays = 2; Date todaysDate = calendar.advance(settlementDate, -fixingDays, Days); Settings::instance().evaluationDate() = todaysDate; std::cout << "Today: " << todaysDate.weekday() << ", " << todaysDate << std::endl; std::cout << "Settlement date: " << settlementDate.weekday() << ", " << settlementDate << std::endl; // Data source: Bloomberg as of 12/30/2011 // deposits Rate d1wQuote=0.00208200; Rate d2wQuote=0.00243500; Rate d1mQuote=0.00295300; Rate d2mQuote=0.00427100; Rate d3mQuote=0.00581000; // futures Real fut1Quote=99.2950; Real fut2Quote=99.2650; Real fut3Quote=99.2450; Real fut4Quote=99.2500; Real fut5Quote=99.2350; Real fut6Quote=99.2100; Real fut7Quote=99.1550; Real fut8Quote=99.1550; // swaps Rate s2yQuote=0.00726000; Rate s3yQuote=0.00820400; Rate s4yQuote=0.01006500; Rate s5yQuote=0.01224500; Rate s6yQuote=0.01449100; Rate s7yQuote=0.01643100; Rate s8yQuote=0.01802800; Rate s9yQuote=0.01932400; Rate s10yQuote=0.02027000; Rate s12yQuote=0.02227100; Rate s15yQuote=0.02401600; /* // Data source: Bloomberg as of 01/31/2012 // deposits Rate d1wQuote=0.00196500; Rate d2wQuote=0.00225500; Rate d1mQuote=0.00264750; Rate d2mQuote=0.00394450; Rate d2mQuote=0.00000000; // futures Real fut1Quote=99.5450; Real fut2Quote=99.5400; Real fut3Quote=99.5200; Real fut4Quote=99.5000; Real fut5Quote=99.4950; Real fut6Quote=99.4750; Real fut7Quote=99.4450; Real fut8Quote=99.4000; // swaps Rate s2yQuote=0.00512500000; Rate s3yQuote=0.00590500000; Rate s4yQuote=0.00764500000; Rate s5yQuote=0.00988000000; Rate s6yQuote=0.01228000000; Rate s7yQuote=0.01449000000; Rate s8yQuote=0.01630500000; Rate s9yQuote=0.01782600000; Rate s10yQuote=0.01915000000; Rate s12yQuote=0.02126000000; Rate s15yQuote=0.02340300000; */ /******************** *** QUOTES *** ********************/ // deposits boost::shared_ptr<Quote> d1wRate(new SimpleQuote(d1wQuote)); boost::shared_ptr<Quote> d2wRate(new SimpleQuote(d2wQuote)); boost::shared_ptr<Quote> d1mRate(new SimpleQuote(d1mQuote)); boost::shared_ptr<Quote> d2mRate(new SimpleQuote(d2mQuote)); boost::shared_ptr<Quote> d3mRate(new SimpleQuote(d3mQuote)); // futures boost::shared_ptr<Quote> fut1Price(new SimpleQuote(fut1Quote)); boost::shared_ptr<Quote> fut2Price(new SimpleQuote(fut2Quote)); boost::shared_ptr<Quote> fut3Price(new SimpleQuote(fut3Quote)); boost::shared_ptr<Quote> fut4Price(new SimpleQuote(fut4Quote)); boost::shared_ptr<Quote> fut5Price(new SimpleQuote(fut5Quote)); boost::shared_ptr<Quote> fut6Price(new SimpleQuote(fut6Quote)); boost::shared_ptr<Quote> fut7Price(new SimpleQuote(fut7Quote)); boost::shared_ptr<Quote> fut8Price(new SimpleQuote(fut8Quote)); // swaps boost::shared_ptr<Quote> s2yRate(new SimpleQuote(s2yQuote)); boost::shared_ptr<Quote> s3yRate(new SimpleQuote(s3yQuote)); boost::shared_ptr<Quote> s4yRate(new SimpleQuote(s4yQuote)); boost::shared_ptr<Quote> s5yRate(new SimpleQuote(s5yQuote)); boost::shared_ptr<Quote> s6yRate(new SimpleQuote(s6yQuote)); boost::shared_ptr<Quote> s7yRate(new SimpleQuote(s7yQuote)); boost::shared_ptr<Quote> s8yRate(new SimpleQuote(s8yQuote)); boost::shared_ptr<Quote> s9yRate(new SimpleQuote(s9yQuote)); boost::shared_ptr<Quote> s10yRate(new SimpleQuote(s10yQuote)); boost::shared_ptr<Quote> s12yRate(new SimpleQuote(s12yQuote)); boost::shared_ptr<Quote> s15yRate(new SimpleQuote(s15yQuote)); /********************* *** RATE HELPERS *** *********************/ // deposits DayCounter depositDayCounter = Actual360(); boost::shared_ptr<RateHelper> d1w(new DepositRateHelper( Handle<Quote>(d1wRate), 1*Weeks, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d2w(new DepositRateHelper( Handle<Quote>(d2wRate), 2*Weeks, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1m(new DepositRateHelper( Handle<Quote>(d1mRate), 1*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d2m(new DepositRateHelper( Handle<Quote>(d2mRate), 2*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d3m(new DepositRateHelper( Handle<Quote>(d3mRate), 3*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); // setup futures // Rate convexityAdjustment = 0.0; Integer futMonths = 3; Date imm = IMM::nextDate(settlementDate); std::cout << "imm1 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut1(new FuturesRateHelper( Handle<Quote>(fut1Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm2 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut2(new FuturesRateHelper( Handle<Quote>(fut2Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm3 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut3(new FuturesRateHelper( Handle<Quote>(fut3Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm4 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut4(new FuturesRateHelper( Handle<Quote>(fut4Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm5 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut5(new FuturesRateHelper( Handle<Quote>(fut5Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm6 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut6(new FuturesRateHelper( Handle<Quote>(fut6Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm7 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut7(new FuturesRateHelper( Handle<Quote>(fut7Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); std::cout << "imm8 = " << imm << std::endl; boost::shared_ptr<RateHelper> fut8(new FuturesRateHelper( Handle<Quote>(fut8Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); // setup swaps Frequency swFixedLegFrequency = Annual; BusinessDayConvention swFixedLegConvention = Unadjusted; DayCounter swFixedLegDayCounter = Thirty360(Thirty360::USA); RelinkableHandle<YieldTermStructure> liborTermStructure; boost::shared_ptr<IborIndex> swFloatingLegIndex(new USDLibor(Period(3, Months), liborTermStructure)); boost::shared_ptr<RateHelper> s2y(new SwapRateHelper( Handle<Quote>(s2yRate), 2*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s3y(new SwapRateHelper( Handle<Quote>(s3yRate), 3*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s4y(new SwapRateHelper( Handle<Quote>(s4yRate), 4*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s5y(new SwapRateHelper( Handle<Quote>(s5yRate), 5*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s6y(new SwapRateHelper( Handle<Quote>(s6yRate), 6*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s7y(new SwapRateHelper( Handle<Quote>(s7yRate), 7*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s8y(new SwapRateHelper( Handle<Quote>(s8yRate), 8*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s9y(new SwapRateHelper( Handle<Quote>(s9yRate), 9*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s10y(new SwapRateHelper( Handle<Quote>(s10yRate), 10*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s12y(new SwapRateHelper( Handle<Quote>(s12yRate), 12*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s15y(new SwapRateHelper( Handle<Quote>(s15yRate), 15*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); /********************* ** CURVE BUILDING ** *********************/ DayCounter termStructureDayCounter = ActualActual(ActualActual::ISDA); double tolerance = 1.0e-15; // A depo-futures-swap curve std::vector<boost::shared_ptr<RateHelper> > depoFutSwapInstruments; depoFutSwapInstruments.push_back(d1w); depoFutSwapInstruments.push_back(d2w); depoFutSwapInstruments.push_back(d1m); depoFutSwapInstruments.push_back(d2m); depoFutSwapInstruments.push_back(d3m); depoFutSwapInstruments.push_back(fut1); depoFutSwapInstruments.push_back(fut2); depoFutSwapInstruments.push_back(fut3); depoFutSwapInstruments.push_back(fut4); depoFutSwapInstruments.push_back(fut5); depoFutSwapInstruments.push_back(fut6); depoFutSwapInstruments.push_back(fut7); depoFutSwapInstruments.push_back(fut8); depoFutSwapInstruments.push_back(s3y); depoFutSwapInstruments.push_back(s4y); depoFutSwapInstruments.push_back(s5y); depoFutSwapInstruments.push_back(s6y); depoFutSwapInstruments.push_back(s7y); depoFutSwapInstruments.push_back(s8y); depoFutSwapInstruments.push_back(s9y); depoFutSwapInstruments.push_back(s10y); depoFutSwapInstruments.push_back(s12y); depoFutSwapInstruments.push_back(s15y); /*boost::shared_ptr<YieldTermStructure> depoFutSwapTermStructure( new PiecewiseYieldCurve<Discount, LogLinear>( settlementDate, depoFutSwapInstruments, termStructureDayCounter, tolerance));*/ PiecewiseYieldCurve<Discount, LogLinear>* depoFutSwapTermStructure = new PiecewiseYieldCurve<Discount, LogLinear>( settlementDate, depoFutSwapInstruments, termStructureDayCounter, tolerance); Date date1 = Date(29, May, 2012); Real df1 = depoFutSwapTermStructure->discount(date1); Date date2 = Date(16, Aug, 2013); Real df2 = depoFutSwapTermStructure->discount(date2); Size widths[] = { 35, 14, 14 }; std::cout << std::setw(widths[0]) << std::left << "Date" << std::setw(widths[1]) << std::left << "Disc. Factor" << std::endl; std::cout << std::setw(widths[0]) << std::left << date1 << std::setw(widths[1]) << std::left << df1 << std::endl; std::cout << std::setw(widths[0]) << std::left << date2 << std::setw(widths[1]) << std::left << df2 << std::endl; return depoFutSwapTermStructure; }
void MainWindow::showSwapNPV() { //ui->lineEdit_SwapNPV->setText(tr("1000000000")); //ui->lineEdit_SwapFairRate->setText(QString::number(3.141659)); //ui->lineEdit_SwapFairSpread->setText(QString::number(2.68796451)); /********************* *** MARKET DATA *** *********************/ Calendar calendar = TARGET(); /////■ Date settlementDate(22, September, 2004); QDate qtFormSettlementDate = ui->dateEdit_settlementDate->date(); QuantLib::Date settlementDate(22, September, 2004); if(!qtFormSettlementDate.isNull() && qtFormSettlementDate.isValid()) { QuantLib::Date settlementDate_(qtFormSettlementDate.day(), (QuantLib::Month)(qtFormSettlementDate.month()), qtFormSettlementDate.year()); settlementDate = settlementDate_; } // must be a business day settlementDate = calendar.adjust(settlementDate); Integer fixingDays = 2; Date todaysDate = calendar.advance(settlementDate, -fixingDays, Days); // nothing to do with Date::todaysDate Settings::instance().evaluationDate() = todaysDate; todaysDate = Settings::instance().evaluationDate(); std::cout << "Today: " << todaysDate.weekday() << ", " << todaysDate << std::endl; std::cout << "Settlement date: " << settlementDate.weekday() << ", " << settlementDate << std::endl; // deposits Rate d1wQuote=0.0382; d1wQuote = static_cast<Rate>(ui->tableWidget_RatesDeposites->item(-1,1)->text().toDouble()*0.01); Rate d1mQuote=0.0372; d1mQuote = static_cast<Rate>(ui->tableWidget_RatesDeposites->item(0,1)->text().toDouble()*0.01); Rate d3mQuote=0.0363; d3mQuote = static_cast<Rate>(ui->tableWidget_RatesDeposites->item(1,1)->text().toDouble()*0.01); Rate d6mQuote=0.0353; d6mQuote = static_cast<Rate>(ui->tableWidget_RatesDeposites->item(2,1)->text().toDouble()*0.01); Rate d9mQuote=0.0348; d9mQuote = static_cast<Rate>(ui->tableWidget_RatesDeposites->item(3,1)->text().toDouble()*0.01); Rate d1yQuote=0.0345; d1yQuote = static_cast<Rate>(ui->tableWidget_RatesDeposites->item(4,1)->text().toDouble()*0.01); // FRAs Rate fra3x6Quote=0.037125; fra3x6Quote = static_cast<Rate>(ui->tableWidget_RatesFRAs->item(-1,1)->text().toDouble()*0.01); Rate fra6x9Quote=0.037125; fra6x9Quote = static_cast<Rate>(ui->tableWidget_RatesFRAs->item(0,1)->text().toDouble()*0.01); Rate fra6x12Quote=0.037125; fra6x12Quote = static_cast<Rate>(ui->tableWidget_RatesFRAs->item(1,1)->text().toDouble()*0.01); // futures Real fut1Quote=96.2875; fut1Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(-1,1)->text().toDouble()); Real fut2Quote=96.7875; fut2Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(0,1)->text().toDouble()); Real fut3Quote=96.9875; fut3Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(1,1)->text().toDouble()); Real fut4Quote=96.6875; fut4Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(2,1)->text().toDouble()); Real fut5Quote=96.4875; fut5Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(3,1)->text().toDouble()); Real fut6Quote=96.3875; fut6Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(4,1)->text().toDouble()); Real fut7Quote=96.2875; fut7Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(5,1)->text().toDouble()); Real fut8Quote=96.0875; fut8Quote = static_cast<Real>(ui->tableWidget_RatesFutures->item(6,1)->text().toDouble()); // swaps Rate s2yQuote=0.037125; s2yQuote = static_cast<Rate>(ui->tableWidget_RatesSwaps->item(-1,1)->text().toDouble()*0.01); Rate s3yQuote=0.0398; s3yQuote = static_cast<Rate>(ui->tableWidget_RatesSwaps->item(0,1)->text().toDouble()*0.01); Rate s5yQuote=0.0443; s5yQuote = static_cast<Rate>(ui->tableWidget_RatesSwaps->item(1,1)->text().toDouble()*0.01); Rate s10yQuote=0.05165; s10yQuote = static_cast<Rate>(ui->tableWidget_RatesSwaps->item(2,1)->text().toDouble()*0.01); Rate s15yQuote=0.055175; s15yQuote = static_cast<Rate>(ui->tableWidget_RatesSwaps->item(3,1)->text().toDouble()*0.01); /******************** *** QUOTES *** ********************/ // SimpleQuote stores a value which can be manually changed; // other Quote subclasses could read the value from a database // or some kind of data feed. // deposits boost::shared_ptr<Quote> d1wRate(new SimpleQuote(d1wQuote)); boost::shared_ptr<Quote> d1mRate(new SimpleQuote(d1mQuote)); boost::shared_ptr<Quote> d3mRate(new SimpleQuote(d3mQuote)); boost::shared_ptr<Quote> d6mRate(new SimpleQuote(d6mQuote)); boost::shared_ptr<Quote> d9mRate(new SimpleQuote(d9mQuote)); boost::shared_ptr<Quote> d1yRate(new SimpleQuote(d1yQuote)); // FRAs boost::shared_ptr<Quote> fra3x6Rate(new SimpleQuote(fra3x6Quote)); boost::shared_ptr<Quote> fra6x9Rate(new SimpleQuote(fra6x9Quote)); boost::shared_ptr<Quote> fra6x12Rate(new SimpleQuote(fra6x12Quote)); // futures boost::shared_ptr<Quote> fut1Price(new SimpleQuote(fut1Quote)); boost::shared_ptr<Quote> fut2Price(new SimpleQuote(fut2Quote)); boost::shared_ptr<Quote> fut3Price(new SimpleQuote(fut3Quote)); boost::shared_ptr<Quote> fut4Price(new SimpleQuote(fut4Quote)); boost::shared_ptr<Quote> fut5Price(new SimpleQuote(fut5Quote)); boost::shared_ptr<Quote> fut6Price(new SimpleQuote(fut6Quote)); boost::shared_ptr<Quote> fut7Price(new SimpleQuote(fut7Quote)); boost::shared_ptr<Quote> fut8Price(new SimpleQuote(fut8Quote)); // swaps boost::shared_ptr<Quote> s2yRate(new SimpleQuote(s2yQuote)); boost::shared_ptr<Quote> s3yRate(new SimpleQuote(s3yQuote)); boost::shared_ptr<Quote> s5yRate(new SimpleQuote(s5yQuote)); boost::shared_ptr<Quote> s10yRate(new SimpleQuote(s10yQuote)); boost::shared_ptr<Quote> s15yRate(new SimpleQuote(s15yQuote)); /********************* *** RATE HELPERS *** *********************/ // RateHelpers are built from the above quotes together with // other instrument dependant infos. Quotes are passed in // relinkable handles which could be relinked to some other // data source later. // deposits DayCounter depositDayCounter = Actual360(); boost::shared_ptr<RateHelper> d1w(new DepositRateHelper( Handle<Quote>(d1wRate), 1*Weeks, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1m(new DepositRateHelper( Handle<Quote>(d1mRate), 1*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d3m(new DepositRateHelper( Handle<Quote>(d3mRate), 3*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d6m(new DepositRateHelper( Handle<Quote>(d6mRate), 6*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d9m(new DepositRateHelper( Handle<Quote>(d9mRate), 9*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1y(new DepositRateHelper( Handle<Quote>(d1yRate), 1*Years, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); // setup FRAs boost::shared_ptr<RateHelper> fra3x6(new FraRateHelper( Handle<Quote>(fra3x6Rate), 3, 6, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> fra6x9(new FraRateHelper( Handle<Quote>(fra6x9Rate), 6, 9, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> fra6x12(new FraRateHelper( Handle<Quote>(fra6x12Rate), 6, 12, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); // setup futures // Rate convexityAdjustment = 0.0; Integer futMonths = 3; Date imm = IMM::nextDate(settlementDate); boost::shared_ptr<RateHelper> fut1(new FuturesRateHelper( Handle<Quote>(fut1Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut2(new FuturesRateHelper( Handle<Quote>(fut2Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut3(new FuturesRateHelper( Handle<Quote>(fut3Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut4(new FuturesRateHelper( Handle<Quote>(fut4Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut5(new FuturesRateHelper( Handle<Quote>(fut5Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut6(new FuturesRateHelper( Handle<Quote>(fut6Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut7(new FuturesRateHelper( Handle<Quote>(fut7Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut8(new FuturesRateHelper( Handle<Quote>(fut8Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); // setup swaps Frequency swFixedLegFrequency = Annual; BusinessDayConvention swFixedLegConvention = Unadjusted; DayCounter swFixedLegDayCounter = Thirty360(Thirty360::European); boost::shared_ptr<IborIndex> swFloatingLegIndex(new Euribor6M); boost::shared_ptr<RateHelper> s2y(new SwapRateHelper( Handle<Quote>(s2yRate), 2*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s3y(new SwapRateHelper( Handle<Quote>(s3yRate), 3*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s5y(new SwapRateHelper( Handle<Quote>(s5yRate), 5*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s10y(new SwapRateHelper( Handle<Quote>(s10yRate), 10*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s15y(new SwapRateHelper( Handle<Quote>(s15yRate), 15*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); /********************* ** CURVE BUILDING ** *********************/ // Any DayCounter would be fine. // ActualActual::ISDA ensures that 30 years is 30.0 DayCounter termStructureDayCounter = ActualActual(ActualActual::ISDA); double tolerance = 1.0e-15; // A depo-swap curve std::vector<boost::shared_ptr<RateHelper> > depoSwapInstruments; depoSwapInstruments.push_back(d1w); depoSwapInstruments.push_back(d1m); depoSwapInstruments.push_back(d3m); depoSwapInstruments.push_back(d6m); depoSwapInstruments.push_back(d9m); depoSwapInstruments.push_back(d1y); depoSwapInstruments.push_back(s2y); depoSwapInstruments.push_back(s3y); depoSwapInstruments.push_back(s5y); depoSwapInstruments.push_back(s10y); depoSwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoSwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoSwapInstruments, termStructureDayCounter, tolerance)); // A depo-futures-swap curve std::vector<boost::shared_ptr<RateHelper> > depoFutSwapInstruments; depoFutSwapInstruments.push_back(d1w); depoFutSwapInstruments.push_back(d1m); depoFutSwapInstruments.push_back(fut1); depoFutSwapInstruments.push_back(fut2); depoFutSwapInstruments.push_back(fut3); depoFutSwapInstruments.push_back(fut4); depoFutSwapInstruments.push_back(fut5); depoFutSwapInstruments.push_back(fut6); depoFutSwapInstruments.push_back(fut7); depoFutSwapInstruments.push_back(fut8); depoFutSwapInstruments.push_back(s3y); depoFutSwapInstruments.push_back(s5y); depoFutSwapInstruments.push_back(s10y); depoFutSwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoFutSwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoFutSwapInstruments, termStructureDayCounter, tolerance)); // A depo-FRA-swap curve std::vector<boost::shared_ptr<RateHelper> > depoFRASwapInstruments; depoFRASwapInstruments.push_back(d1w); depoFRASwapInstruments.push_back(d1m); depoFRASwapInstruments.push_back(d3m); depoFRASwapInstruments.push_back(fra3x6); depoFRASwapInstruments.push_back(fra6x9); depoFRASwapInstruments.push_back(fra6x12); depoFRASwapInstruments.push_back(s2y); depoFRASwapInstruments.push_back(s3y); depoFRASwapInstruments.push_back(s5y); depoFRASwapInstruments.push_back(s10y); depoFRASwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoFRASwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoFRASwapInstruments, termStructureDayCounter, tolerance)); // Term structures that will be used for pricing: // the one used for discounting cash flows RelinkableHandle<YieldTermStructure> discountingTermStructure; // the one used for forward rate forecasting RelinkableHandle<YieldTermStructure> forecastingTermStructure; /********************* * SWAPS TO BE PRICED * **********************/ // constant nominal 1,000,000 Euro /////■ Real nominal = 1000000.0; Real nominal = static_cast<Real>(ui->doubleSpinBox_Notional->value()); // fixed leg /////■ Frequency fixedLegFrequency = Annual; Frequency fixedLegFrequency = Annual; /////■ BusinessDayConvention fixedLegConvention = Unadjusted; BusinessDayConvention fixedLegConvention = Unadjusted; /////■ DayCounter fixedLegDayCounter = Thirty360(Thirty360::European); DayCounter fixedLegDayCounter = Thirty360(Thirty360::European); /////■ Rate fixedRate = 0.04; Rate fixedRate = static_cast<Real>((ui->doubleSpinBox_fixedRate->value())*0.01); // floating leg /////■ Frequency floatingLegFrequency = Semiannual; Frequency floatingLegFrequency = Semiannual; int comboBoxFloatingLegFrequency = ui->comboBox_FloatingLegFrequency->currentIndex(); switch(comboBoxFloatingLegFrequency) { case 0: // Semiannual floatingLegFrequency = Semiannual; break; case 1: // Annual floatingLegFrequency = Annual; break; case 2: // Quarterly floatingLegFrequency = Quarterly; break; } /////■ BusinessDayConvention floatingLegConvention = ModifiedFollowing; BusinessDayConvention floatingLegConvention = ModifiedFollowing; /////■ DayCounter floatingLegDayCounter = Actual360(); DayCounter floatingLegDayCounter = Actual360(); boost::shared_ptr<IborIndex> euriborIndex( new Euribor6M(forecastingTermStructure)); /////■ Spread spread = 0.0; Spread spread = static_cast<Spread>((ui->doubleSpinBox_spread->value())*0.01); /////■ Integer lenghtInYears = 5; Integer lenghtInYears = (Integer)(ui->doubleSpinBox_lenghtInYears->value()); /////■ VanillaSwap::Type swapType = VanillaSwap::Payer; int comboBoxPayerReceiver = ui->comboBox_swapType->currentIndex(); VanillaSwap::Type swapType = VanillaSwap::Receiver; switch(comboBoxPayerReceiver) { case 0: // Fix Payer swapType = VanillaSwap::Payer; break; // VanillaSwap::Payer=1 case 1: // Fix Receiver swapType = VanillaSwap::Receiver; break; // VanillaSwap::Receiver=-1 } Date maturity = settlementDate + lenghtInYears*Years; Schedule fixedSchedule(settlementDate, maturity, Period(fixedLegFrequency), calendar, fixedLegConvention, fixedLegConvention, DateGeneration::Forward, false); Schedule floatSchedule(settlementDate, maturity, Period(floatingLegFrequency), calendar, floatingLegConvention, floatingLegConvention, DateGeneration::Forward, false); VanillaSwap spot5YearSwap(swapType, nominal, fixedSchedule, fixedRate, fixedLegDayCounter, floatSchedule, euriborIndex, spread, floatingLegDayCounter); Date fwdStart = calendar.advance(settlementDate, 1, Years); Date fwdMaturity = fwdStart + lenghtInYears*Years; Schedule fwdFixedSchedule(fwdStart, fwdMaturity, Period(fixedLegFrequency), calendar, fixedLegConvention, fixedLegConvention, DateGeneration::Forward, false); Schedule fwdFloatSchedule(fwdStart, fwdMaturity, Period(floatingLegFrequency), calendar, floatingLegConvention, floatingLegConvention, DateGeneration::Forward, false); VanillaSwap oneYearForward5YearSwap(swapType, nominal, fwdFixedSchedule, fixedRate, fixedLegDayCounter, fwdFloatSchedule, euriborIndex, spread, floatingLegDayCounter); /*************** * SWAP PRICING * ****************/ Real NPV; Rate fairRate; Spread fairSpread; boost::shared_ptr<PricingEngine> swapEngine( new DiscountingSwapEngine(discountingTermStructure)); spot5YearSwap.setPricingEngine(swapEngine); oneYearForward5YearSwap.setPricingEngine(swapEngine); int swapTermStructureType(0); swapTermStructureType = ui->comboBox_TermStructureType->currentIndex(); //QMessageBox msgBoxTmp(this); msgBoxTmp.setText(QString::number(swapTermStructureType)); msgBoxTmp.exec(); switch(swapTermStructureType) { case 0: forecastingTermStructure.linkTo(depoSwapTermStructure); discountingTermStructure.linkTo(depoSwapTermStructure); break; case 1: forecastingTermStructure.linkTo(depoFutSwapTermStructure); discountingTermStructure.linkTo(depoFutSwapTermStructure); break; case 2: forecastingTermStructure.linkTo(depoFRASwapTermStructure); discountingTermStructure.linkTo(depoFRASwapTermStructure); break; } NPV = spot5YearSwap.NPV(); fairRate = spot5YearSwap.fairRate(); fairSpread = spot5YearSwap.fairSpread(); ui->lineEdit_SwapNPV->setText(QString::number(static_cast<double>(NPV),'f')); ui->lineEdit_SwapFairRate->setText(QString::number(static_cast<double>(fairRate*100.0),'f')); ui->lineEdit_SwapFairSpread->setText(QString::number(static_cast<double>(fairSpread*100.0),'f')); }
int main(int, char* []) { try { boost::timer timer; std::cout << std::endl; Option::Type type(Option::Put); Real underlying = 36.0; Real spreadRate = 0.005; Spread dividendYield = 0.02; Rate riskFreeRate = 0.06; Volatility volatility = 0.20; Integer settlementDays = 3; Integer length = 5; Real redemption = 100.0; Real conversionRatio = redemption/underlying; // at the money // set up dates/schedules Calendar calendar = TARGET(); Date today = calendar.adjust(Date::todaysDate()); Settings::instance().evaluationDate() = today; Date settlementDate = calendar.advance(today, settlementDays, Days); Date exerciseDate = calendar.advance(settlementDate, length, Years); Date issueDate = calendar.advance(exerciseDate, -length, Years); BusinessDayConvention convention = ModifiedFollowing; Frequency frequency = Annual; Schedule schedule(issueDate, exerciseDate, Period(frequency), calendar, convention, convention, DateGeneration::Backward, false); DividendSchedule dividends; CallabilitySchedule callability; std::vector<Real> coupons(1, 0.05); DayCounter bondDayCount = Thirty360(); Integer callLength[] = { 2, 4 }; // Call dates, years 2, 4. Integer putLength[] = { 3 }; // Put dates year 3 Real callPrices[] = { 101.5, 100.85 }; Real putPrices[]= { 105.0 }; // Load call schedules for (Size i=0; i<LENGTH(callLength); i++) { callability.push_back( boost::shared_ptr<Callability>( new SoftCallability(Callability::Price( callPrices[i], Callability::Price::Clean), schedule.date(callLength[i]), 1.20))); } for (Size j=0; j<LENGTH(putLength); j++) { callability.push_back( boost::shared_ptr<Callability>( new Callability(Callability::Price( putPrices[j], Callability::Price::Clean), Callability::Put, schedule.date(putLength[j])))); } // Assume dividends are paid every 6 months. for (Date d = today + 6*Months; d < exerciseDate; d += 6*Months) { dividends.push_back( boost::shared_ptr<Dividend>(new FixedDividend(1.0, d))); } DayCounter dayCounter = Actual365Fixed(); Time maturity = dayCounter.yearFraction(settlementDate, exerciseDate); std::cout << "option type = " << type << std::endl; std::cout << "Time to maturity = " << maturity << std::endl; std::cout << "Underlying price = " << underlying << std::endl; std::cout << "Risk-free interest rate = " << io::rate(riskFreeRate) << std::endl; std::cout << "Dividend yield = " << io::rate(dividendYield) << std::endl; std::cout << "Volatility = " << io::volatility(volatility) << std::endl; std::cout << std::endl; std::string method; std::cout << std::endl ; // write column headings Size widths[] = { 35, 14, 14 }; Size totalWidth = widths[0] + widths[1] + widths[2]; std::string rule(totalWidth, '-'), dblrule(totalWidth, '='); std::cout << dblrule << std::endl; std::cout << "Tsiveriotis-Fernandes method" << std::endl; std::cout << dblrule << std::endl; std::cout << std::setw(widths[0]) << std::left << "Tree type" << std::setw(widths[1]) << std::left << "European" << std::setw(widths[1]) << std::left << "American" << std::endl; std::cout << rule << std::endl; boost::shared_ptr<Exercise> exercise( new EuropeanExercise(exerciseDate)); boost::shared_ptr<Exercise> amExercise( new AmericanExercise(settlementDate, exerciseDate)); Handle<Quote> underlyingH( boost::shared_ptr<Quote>(new SimpleQuote(underlying))); Handle<YieldTermStructure> flatTermStructure( boost::shared_ptr<YieldTermStructure>( new FlatForward(settlementDate, riskFreeRate, dayCounter))); Handle<YieldTermStructure> flatDividendTS( boost::shared_ptr<YieldTermStructure>( new FlatForward(settlementDate, dividendYield, dayCounter))); Handle<BlackVolTermStructure> flatVolTS( boost::shared_ptr<BlackVolTermStructure>( new BlackConstantVol(settlementDate, calendar, volatility, dayCounter))); boost::shared_ptr<BlackScholesMertonProcess> stochasticProcess( new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS)); Size timeSteps = 801; Handle<Quote> creditSpread( boost::shared_ptr<Quote>(new SimpleQuote(spreadRate))); boost::shared_ptr<Quote> rate(new SimpleQuote(riskFreeRate)); Handle<YieldTermStructure> discountCurve( boost::shared_ptr<YieldTermStructure>( new FlatForward(today, Handle<Quote>(rate), dayCounter))); boost::shared_ptr<PricingEngine> engine( new BinomialConvertibleEngine<JarrowRudd>(stochasticProcess, timeSteps)); ConvertibleFixedCouponBond europeanBond( exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, coupons, bondDayCount, schedule, redemption); europeanBond.setPricingEngine(engine); ConvertibleFixedCouponBond americanBond( amExercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, coupons, bondDayCount, schedule, redemption); americanBond.setPricingEngine(engine); method = "Jarrow-Rudd"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<JarrowRudd>(stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<JarrowRudd>(stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; method = "Cox-Ross-Rubinstein"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<CoxRossRubinstein>(stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<CoxRossRubinstein>(stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; method = "Additive equiprobabilities"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<AdditiveEQPBinomialTree>( stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<AdditiveEQPBinomialTree>( stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; method = "Trigeorgis"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<Trigeorgis>(stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<Trigeorgis>(stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; method = "Tian"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<Tian>(stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<Tian>(stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; method = "Leisen-Reimer"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<LeisenReimer>(stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<LeisenReimer>(stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; method = "Joshi"; europeanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<Joshi4>(stochasticProcess, timeSteps))); americanBond.setPricingEngine(boost::shared_ptr<PricingEngine>( new BinomialConvertibleEngine<Joshi4>(stochasticProcess, timeSteps))); std::cout << std::setw(widths[0]) << std::left << method << std::fixed << std::setw(widths[1]) << std::left << europeanBond.NPV() << std::setw(widths[2]) << std::left << americanBond.NPV() << std::endl; std::cout << dblrule << std::endl; Real seconds = timer.elapsed(); Integer hours = int(seconds/3600); seconds -= hours * 3600; Integer minutes = int(seconds/60); seconds -= minutes * 60; std::cout << " \nRun completed in "; if (hours > 0) std::cout << hours << " h "; if (hours > 0 || minutes > 0) std::cout << minutes << " m "; std::cout << std::fixed << std::setprecision(0) << seconds << " s\n" << std::endl; return 0; } catch (std::exception& e) { std::cerr << e.what() << std::endl; return 1; } catch (...) { std::cerr << "unknown error" << std::endl; return 1; } }
void QtSwap::qtswap() { try { boost::timer timer; std::cout << std::endl; /********************* *** MARKET DATA *** *********************/ Calendar calendar = TARGET(); Date settlementDate(22, September, 2004); // must be a business day settlementDate = calendar.adjust(settlementDate); Integer fixingDays = 2; Date todaysDate = calendar.advance(settlementDate, -fixingDays, Days); // nothing to do with Date::todaysDate Settings::instance().evaluationDate() = todaysDate; todaysDate = Settings::instance().evaluationDate(); std::cout << "Today: " << todaysDate.weekday() << ", " << todaysDate << std::endl; std::cout << "Settlement date: " << settlementDate.weekday() << ", " << settlementDate << std::endl; // deposits Rate d1wQuote=0.0382; Rate d1mQuote=0.0372; Rate d3mQuote=0.0363; Rate d6mQuote=0.0353; Rate d9mQuote=0.0348; Rate d1yQuote=0.0345; // FRAs Rate fra3x6Quote=0.037125; Rate fra6x9Quote=0.037125; Rate fra6x12Quote=0.037125; // futures Real fut1Quote=96.2875; Real fut2Quote=96.7875; Real fut3Quote=96.9875; Real fut4Quote=96.6875; Real fut5Quote=96.4875; Real fut6Quote=96.3875; Real fut7Quote=96.2875; Real fut8Quote=96.0875; // swaps Rate s2yQuote=0.037125; Rate s3yQuote=0.0398; Rate s5yQuote=0.0443; Rate s10yQuote=0.05165; Rate s15yQuote=0.055175; /******************** *** QUOTES *** ********************/ // SimpleQuote stores a value which can be manually changed; // other Quote subclasses could read the value from a database // or some kind of data feed. // deposits boost::shared_ptr<Quote> d1wRate(new SimpleQuote(d1wQuote)); boost::shared_ptr<Quote> d1mRate(new SimpleQuote(d1mQuote)); boost::shared_ptr<Quote> d3mRate(new SimpleQuote(d3mQuote)); boost::shared_ptr<Quote> d6mRate(new SimpleQuote(d6mQuote)); boost::shared_ptr<Quote> d9mRate(new SimpleQuote(d9mQuote)); boost::shared_ptr<Quote> d1yRate(new SimpleQuote(d1yQuote)); // FRAs boost::shared_ptr<Quote> fra3x6Rate(new SimpleQuote(fra3x6Quote)); boost::shared_ptr<Quote> fra6x9Rate(new SimpleQuote(fra6x9Quote)); boost::shared_ptr<Quote> fra6x12Rate(new SimpleQuote(fra6x12Quote)); // futures boost::shared_ptr<Quote> fut1Price(new SimpleQuote(fut1Quote)); boost::shared_ptr<Quote> fut2Price(new SimpleQuote(fut2Quote)); boost::shared_ptr<Quote> fut3Price(new SimpleQuote(fut3Quote)); boost::shared_ptr<Quote> fut4Price(new SimpleQuote(fut4Quote)); boost::shared_ptr<Quote> fut5Price(new SimpleQuote(fut5Quote)); boost::shared_ptr<Quote> fut6Price(new SimpleQuote(fut6Quote)); boost::shared_ptr<Quote> fut7Price(new SimpleQuote(fut7Quote)); boost::shared_ptr<Quote> fut8Price(new SimpleQuote(fut8Quote)); // swaps boost::shared_ptr<Quote> s2yRate(new SimpleQuote(s2yQuote)); boost::shared_ptr<Quote> s3yRate(new SimpleQuote(s3yQuote)); boost::shared_ptr<Quote> s5yRate(new SimpleQuote(s5yQuote)); boost::shared_ptr<Quote> s10yRate(new SimpleQuote(s10yQuote)); boost::shared_ptr<Quote> s15yRate(new SimpleQuote(s15yQuote)); /********************* *** RATE HELPERS *** *********************/ // RateHelpers are built from the above quotes together with // other instrument dependant infos. Quotes are passed in // relinkable handles which could be relinked to some other // data source later. // deposits DayCounter depositDayCounter = Actual360(); boost::shared_ptr<RateHelper> d1w(new DepositRateHelper( Handle<Quote>(d1wRate), 1*Weeks, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1m(new DepositRateHelper( Handle<Quote>(d1mRate), 1*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d3m(new DepositRateHelper( Handle<Quote>(d3mRate), 3*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d6m(new DepositRateHelper( Handle<Quote>(d6mRate), 6*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d9m(new DepositRateHelper( Handle<Quote>(d9mRate), 9*Months, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> d1y(new DepositRateHelper( Handle<Quote>(d1yRate), 1*Years, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); // setup FRAs boost::shared_ptr<RateHelper> fra3x6(new FraRateHelper( Handle<Quote>(fra3x6Rate), 3, 6, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> fra6x9(new FraRateHelper( Handle<Quote>(fra6x9Rate), 6, 9, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); boost::shared_ptr<RateHelper> fra6x12(new FraRateHelper( Handle<Quote>(fra6x12Rate), 6, 12, fixingDays, calendar, ModifiedFollowing, true, depositDayCounter)); // setup futures // Rate convexityAdjustment = 0.0; Integer futMonths = 3; Date imm = IMM::nextDate(settlementDate); boost::shared_ptr<RateHelper> fut1(new FuturesRateHelper( Handle<Quote>(fut1Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut2(new FuturesRateHelper( Handle<Quote>(fut2Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut3(new FuturesRateHelper( Handle<Quote>(fut3Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut4(new FuturesRateHelper( Handle<Quote>(fut4Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut5(new FuturesRateHelper( Handle<Quote>(fut5Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut6(new FuturesRateHelper( Handle<Quote>(fut6Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut7(new FuturesRateHelper( Handle<Quote>(fut7Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); imm = IMM::nextDate(imm+1); boost::shared_ptr<RateHelper> fut8(new FuturesRateHelper( Handle<Quote>(fut8Price), imm, futMonths, calendar, ModifiedFollowing, true, depositDayCounter)); // setup swaps Frequency swFixedLegFrequency = Annual; BusinessDayConvention swFixedLegConvention = Unadjusted; DayCounter swFixedLegDayCounter = Thirty360(Thirty360::European); boost::shared_ptr<IborIndex> swFloatingLegIndex(new Euribor6M); boost::shared_ptr<RateHelper> s2y(new SwapRateHelper( Handle<Quote>(s2yRate), 2*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s3y(new SwapRateHelper( Handle<Quote>(s3yRate), 3*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s5y(new SwapRateHelper( Handle<Quote>(s5yRate), 5*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s10y(new SwapRateHelper( Handle<Quote>(s10yRate), 10*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); boost::shared_ptr<RateHelper> s15y(new SwapRateHelper( Handle<Quote>(s15yRate), 15*Years, calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex)); /********************* ** CURVE BUILDING ** *********************/ // Any DayCounter would be fine. // ActualActual::ISDA ensures that 30 years is 30.0 DayCounter termStructureDayCounter = ActualActual(ActualActual::ISDA); double tolerance = 1.0e-15; // A depo-swap curve std::vector<boost::shared_ptr<RateHelper> > depoSwapInstruments; depoSwapInstruments.push_back(d1w); depoSwapInstruments.push_back(d1m); depoSwapInstruments.push_back(d3m); depoSwapInstruments.push_back(d6m); depoSwapInstruments.push_back(d9m); depoSwapInstruments.push_back(d1y); depoSwapInstruments.push_back(s2y); depoSwapInstruments.push_back(s3y); depoSwapInstruments.push_back(s5y); depoSwapInstruments.push_back(s10y); depoSwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoSwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoSwapInstruments, termStructureDayCounter, tolerance)); // A depo-futures-swap curve std::vector<boost::shared_ptr<RateHelper> > depoFutSwapInstruments; depoFutSwapInstruments.push_back(d1w); depoFutSwapInstruments.push_back(d1m); depoFutSwapInstruments.push_back(fut1); depoFutSwapInstruments.push_back(fut2); depoFutSwapInstruments.push_back(fut3); depoFutSwapInstruments.push_back(fut4); depoFutSwapInstruments.push_back(fut5); depoFutSwapInstruments.push_back(fut6); depoFutSwapInstruments.push_back(fut7); depoFutSwapInstruments.push_back(fut8); depoFutSwapInstruments.push_back(s3y); depoFutSwapInstruments.push_back(s5y); depoFutSwapInstruments.push_back(s10y); depoFutSwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoFutSwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoFutSwapInstruments, termStructureDayCounter, tolerance)); // A depo-FRA-swap curve std::vector<boost::shared_ptr<RateHelper> > depoFRASwapInstruments; depoFRASwapInstruments.push_back(d1w); depoFRASwapInstruments.push_back(d1m); depoFRASwapInstruments.push_back(d3m); depoFRASwapInstruments.push_back(fra3x6); depoFRASwapInstruments.push_back(fra6x9); depoFRASwapInstruments.push_back(fra6x12); depoFRASwapInstruments.push_back(s2y); depoFRASwapInstruments.push_back(s3y); depoFRASwapInstruments.push_back(s5y); depoFRASwapInstruments.push_back(s10y); depoFRASwapInstruments.push_back(s15y); boost::shared_ptr<YieldTermStructure> depoFRASwapTermStructure( new PiecewiseYieldCurve<Discount,LogLinear>( settlementDate, depoFRASwapInstruments, termStructureDayCounter, tolerance)); // Term structures that will be used for pricing: // the one used for discounting cash flows RelinkableHandle<YieldTermStructure> discountingTermStructure; // the one used for forward rate forecasting RelinkableHandle<YieldTermStructure> forecastingTermStructure; /********************* * SWAPS TO BE PRICED * **********************/ // constant nominal 1,000,000 Euro Real nominal = 1000000.0; // fixed leg Frequency fixedLegFrequency = Annual; BusinessDayConvention fixedLegConvention = Unadjusted; BusinessDayConvention floatingLegConvention = ModifiedFollowing; DayCounter fixedLegDayCounter = Thirty360(Thirty360::European); Rate fixedRate = 0.04; DayCounter floatingLegDayCounter = Actual360(); // floating leg Frequency floatingLegFrequency = Semiannual; boost::shared_ptr<IborIndex> euriborIndex( new Euribor6M(forecastingTermStructure)); Spread spread = 0.0; Integer lenghtInYears = 5; VanillaSwap::Type swapType = VanillaSwap::Payer; Date maturity = settlementDate + lenghtInYears*Years; Schedule fixedSchedule(settlementDate, maturity, Period(fixedLegFrequency), calendar, fixedLegConvention, fixedLegConvention, DateGeneration::Forward, false); Schedule floatSchedule(settlementDate, maturity, Period(floatingLegFrequency), calendar, floatingLegConvention, floatingLegConvention, DateGeneration::Forward, false); VanillaSwap spot5YearSwap(swapType, nominal, fixedSchedule, fixedRate, fixedLegDayCounter, floatSchedule, euriborIndex, spread, floatingLegDayCounter); Date fwdStart = calendar.advance(settlementDate, 1, Years); Date fwdMaturity = fwdStart + lenghtInYears*Years; Schedule fwdFixedSchedule(fwdStart, fwdMaturity, Period(fixedLegFrequency), calendar, fixedLegConvention, fixedLegConvention, DateGeneration::Forward, false); Schedule fwdFloatSchedule(fwdStart, fwdMaturity, Period(floatingLegFrequency), calendar, floatingLegConvention, floatingLegConvention, DateGeneration::Forward, false); VanillaSwap oneYearForward5YearSwap(swapType, nominal, fwdFixedSchedule, fixedRate, fixedLegDayCounter, fwdFloatSchedule, euriborIndex, spread, floatingLegDayCounter); /*************** * SWAP PRICING * ****************/ // utilities for reporting std::vector<std::string> headers(4); headers[0] = "term structure"; headers[1] = "net present value"; headers[2] = "fair spread"; headers[3] = "fair fixed rate"; std::string separator = " | "; Size width = headers[0].size() + separator.size() + headers[1].size() + separator.size() + headers[2].size() + separator.size() + headers[3].size() + separator.size() - 1; std::string rule(width, '-'), dblrule(width, '='); std::string tab(8, ' '); // calculations std::cout << dblrule << std::endl; std::cout << "5-year market swap-rate = " << std::setprecision(2) << io::rate(s5yRate->value()) << std::endl; std::cout << dblrule << std::endl; std::cout << tab << "5-years swap paying " << io::rate(fixedRate) << std::endl; std::cout << headers[0] << separator << headers[1] << separator << headers[2] << separator << headers[3] << separator << std::endl; std::cout << rule << std::endl; Real NPV; Rate fairRate; Spread fairSpread; boost::shared_ptr<PricingEngine> swapEngine( new DiscountingSwapEngine(discountingTermStructure)); spot5YearSwap.setPricingEngine(swapEngine); oneYearForward5YearSwap.setPricingEngine(swapEngine); // Of course, you're not forced to really use different curves forecastingTermStructure.linkTo(depoSwapTermStructure); discountingTermStructure.linkTo(depoSwapTermStructure); NPV = spot5YearSwap.NPV(); fairSpread = spot5YearSwap.fairSpread(); fairRate = spot5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; // let's check that the 5 years swap has been correctly re-priced QL_REQUIRE(std::fabs(fairRate-s5yQuote)<1e-8, "5-years swap mispriced by " << io::rate(std::fabs(fairRate-s5yQuote))); forecastingTermStructure.linkTo(depoFutSwapTermStructure); discountingTermStructure.linkTo(depoFutSwapTermStructure); NPV = spot5YearSwap.NPV(); fairSpread = spot5YearSwap.fairSpread(); fairRate = spot5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-fut-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; QL_REQUIRE(std::fabs(fairRate-s5yQuote)<1e-8, "5-years swap mispriced!"); forecastingTermStructure.linkTo(depoFRASwapTermStructure); discountingTermStructure.linkTo(depoFRASwapTermStructure); NPV = spot5YearSwap.NPV(); fairSpread = spot5YearSwap.fairSpread(); fairRate = spot5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-FRA-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; QL_REQUIRE(std::fabs(fairRate-s5yQuote)<1e-8, "5-years swap mispriced!"); std::cout << rule << std::endl; // now let's price the 1Y forward 5Y swap std::cout << tab << "5-years, 1-year forward swap paying " << io::rate(fixedRate) << std::endl; std::cout << headers[0] << separator << headers[1] << separator << headers[2] << separator << headers[3] << separator << std::endl; std::cout << rule << std::endl; forecastingTermStructure.linkTo(depoSwapTermStructure); discountingTermStructure.linkTo(depoSwapTermStructure); NPV = oneYearForward5YearSwap.NPV(); fairSpread = oneYearForward5YearSwap.fairSpread(); fairRate = oneYearForward5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; forecastingTermStructure.linkTo(depoFutSwapTermStructure); discountingTermStructure.linkTo(depoFutSwapTermStructure); NPV = oneYearForward5YearSwap.NPV(); fairSpread = oneYearForward5YearSwap.fairSpread(); fairRate = oneYearForward5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-fut-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; forecastingTermStructure.linkTo(depoFRASwapTermStructure); discountingTermStructure.linkTo(depoFRASwapTermStructure); NPV = oneYearForward5YearSwap.NPV(); fairSpread = oneYearForward5YearSwap.fairSpread(); fairRate = oneYearForward5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-FRA-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; // now let's say that the 5-years swap rate goes up to 4.60%. // A smarter market element--say, connected to a data source-- would // notice the change itself. Since we're using SimpleQuotes, // we'll have to change the value manually--which forces us to // downcast the handle and use the SimpleQuote // interface. In any case, the point here is that a change in the // value contained in the Quote triggers a new bootstrapping // of the curve and a repricing of the swap. boost::shared_ptr<SimpleQuote> fiveYearsRate = boost::dynamic_pointer_cast<SimpleQuote>(s5yRate); fiveYearsRate->setValue(0.0460); std::cout << dblrule << std::endl; std::cout << "5-year market swap-rate = " << io::rate(s5yRate->value()) << std::endl; std::cout << dblrule << std::endl; std::cout << tab << "5-years swap paying " << io::rate(fixedRate) << std::endl; std::cout << headers[0] << separator << headers[1] << separator << headers[2] << separator << headers[3] << separator << std::endl; std::cout << rule << std::endl; // now get the updated results forecastingTermStructure.linkTo(depoSwapTermStructure); discountingTermStructure.linkTo(depoSwapTermStructure); NPV = spot5YearSwap.NPV(); fairSpread = spot5YearSwap.fairSpread(); fairRate = spot5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; QL_REQUIRE(std::fabs(fairRate-s5yRate->value())<1e-8, "5-years swap mispriced!"); forecastingTermStructure.linkTo(depoFutSwapTermStructure); discountingTermStructure.linkTo(depoFutSwapTermStructure); NPV = spot5YearSwap.NPV(); fairSpread = spot5YearSwap.fairSpread(); fairRate = spot5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-fut-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; QL_REQUIRE(std::fabs(fairRate-s5yRate->value())<1e-8, "5-years swap mispriced!"); forecastingTermStructure.linkTo(depoFRASwapTermStructure); discountingTermStructure.linkTo(depoFRASwapTermStructure); NPV = spot5YearSwap.NPV(); fairSpread = spot5YearSwap.fairSpread(); fairRate = spot5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-FRA-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; QL_REQUIRE(std::fabs(fairRate-s5yRate->value())<1e-8, "5-years swap mispriced!"); std::cout << rule << std::endl; // the 1Y forward 5Y swap changes as well std::cout << tab << "5-years, 1-year forward swap paying " << io::rate(fixedRate) << std::endl; std::cout << headers[0] << separator << headers[1] << separator << headers[2] << separator << headers[3] << separator << std::endl; std::cout << rule << std::endl; forecastingTermStructure.linkTo(depoSwapTermStructure); discountingTermStructure.linkTo(depoSwapTermStructure); NPV = oneYearForward5YearSwap.NPV(); fairSpread = oneYearForward5YearSwap.fairSpread(); fairRate = oneYearForward5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; forecastingTermStructure.linkTo(depoFutSwapTermStructure); discountingTermStructure.linkTo(depoFutSwapTermStructure); NPV = oneYearForward5YearSwap.NPV(); fairSpread = oneYearForward5YearSwap.fairSpread(); fairRate = oneYearForward5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-fut-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; forecastingTermStructure.linkTo(depoFRASwapTermStructure); discountingTermStructure.linkTo(depoFRASwapTermStructure); NPV = oneYearForward5YearSwap.NPV(); fairSpread = oneYearForward5YearSwap.fairSpread(); fairRate = oneYearForward5YearSwap.fairRate(); std::cout << std::setw(headers[0].size()) << "depo-FRA-swap" << separator; std::cout << std::setw(headers[1].size()) << std::fixed << std::setprecision(2) << NPV << separator; std::cout << std::setw(headers[2].size()) << io::rate(fairSpread) << separator; std::cout << std::setw(headers[3].size()) << io::rate(fairRate) << separator; std::cout << std::endl; Real seconds = timer.elapsed(); Integer hours = int(seconds/3600); seconds -= hours * 3600; Integer minutes = int(seconds/60); seconds -= minutes * 60; std::cout << " \nRun completed in "; if (hours > 0) std::cout << hours << " h "; if (hours > 0 || minutes > 0) std::cout << minutes << " m "; std::cout << std::fixed << std::setprecision(0) << seconds << " s\n" << std::endl; } catch (std::exception& e) { std::cerr << e.what() << std::endl; } catch (...) { std::cerr << "unknown error" << std::endl; } }
void InflationTest::testZeroTermStructure() { BOOST_MESSAGE("Testing zero inflation term structure..."); SavedSettings backup; // try the Zero UK Calendar calendar = UnitedKingdom(); BusinessDayConvention bdc = ModifiedFollowing; Date evaluationDate(13, August, 2007); evaluationDate = calendar.adjust(evaluationDate); Settings::instance().evaluationDate() = evaluationDate; // fixing data Date from(1, January, 2005); Date to(13, August, 2007); Schedule rpiSchedule = MakeSchedule().from(from).to(to) .withTenor(1*Months) .withCalendar(UnitedKingdom()) .withConvention(ModifiedFollowing); Real fixData[] = { 189.9, 189.9, 189.6, 190.5, 191.6, 192.0, 192.2, 192.2, 192.6, 193.1, 193.3, 193.6, 194.1, 193.4, 194.2, 195.0, 196.5, 197.7, 198.5, 198.5, 199.2, 200.1, 200.4, 201.1, 202.7, 201.6, 203.1, 204.4, 205.4, 206.2, 207.3, 206.1, -999.0 }; RelinkableHandle<ZeroInflationTermStructure> hz; bool interp = false; boost::shared_ptr<UKRPI> iiUKRPI(new UKRPI(interp, hz)); for (Size i=0; i<rpiSchedule.size();i++) { iiUKRPI->addFixing(rpiSchedule[i], fixData[i]); } boost::shared_ptr<ZeroInflationIndex> ii = boost::dynamic_pointer_cast<ZeroInflationIndex>(iiUKRPI); boost::shared_ptr<YieldTermStructure> nominalTS = nominalTermStructure(); // now build the zero inflation curve Datum zcData[] = { { Date(13, August, 2008), 2.93 }, { Date(13, August, 2009), 2.95 }, { Date(13, August, 2010), 2.965 }, { Date(15, August, 2011), 2.98 }, { Date(13, August, 2012), 3.0 }, { Date(13, August, 2014), 3.06 }, { Date(13, August, 2017), 3.175 }, { Date(13, August, 2019), 3.243 }, { Date(15, August, 2022), 3.293 }, { Date(14, August, 2027), 3.338 }, { Date(13, August, 2032), 3.348 }, { Date(15, August, 2037), 3.348 }, { Date(13, August, 2047), 3.308 }, { Date(13, August, 2057), 3.228 } }; Period observationLag = Period(2,Months); DayCounter dc = Thirty360(); Frequency frequency = Monthly; std::vector<boost::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > > helpers = makeHelpers<ZeroInflationTermStructure,ZeroCouponInflationSwapHelper, ZeroInflationIndex>(zcData, LENGTH(zcData), ii, observationLag, calendar, bdc, dc); Rate baseZeroRate = zcData[0].rate/100.0; boost::shared_ptr<PiecewiseZeroInflationCurve<Linear> > pZITS( new PiecewiseZeroInflationCurve<Linear>( evaluationDate, calendar, dc, observationLag, frequency, ii->interpolated(), baseZeroRate, Handle<YieldTermStructure>(nominalTS), helpers)); pZITS->recalculate(); // first check that the zero rates on the curve match the data // and that the helpers give the correct impled rates const Real eps = 0.00000001; bool forceLinearInterpolation = false; for (Size i=0; i<LENGTH(zcData); i++) { BOOST_REQUIRE_MESSAGE(std::fabs(zcData[i].rate/100.0 - pZITS->zeroRate(zcData[i].date, observationLag, forceLinearInterpolation)) < eps, "ZITS zeroRate != instrument " << pZITS->zeroRate(zcData[i].date, observationLag, forceLinearInterpolation) << " vs " << zcData[i].rate/100.0 << " interpolation: " << ii->interpolated() << " forceLinearInterpolation " << forceLinearInterpolation); BOOST_REQUIRE_MESSAGE(std::fabs(helpers[i]->impliedQuote() - zcData[i].rate/100.0) < eps, "ZITS implied quote != instrument " << helpers[i]->impliedQuote() << " vs " << zcData[i].rate/100.0); } // now test the forecasting capability of the index. hz.linkTo(pZITS); from = hz->baseDate(); to = hz->maxDate()-1*Months; // a bit of margin for adjustments Schedule testIndex = MakeSchedule().from(from).to(to) .withTenor(1*Months) .withCalendar(UnitedKingdom()) .withConvention(ModifiedFollowing); // we are testing UKRPI which is not interpolated Date bd = hz->baseDate(); Real bf = ii->fixing(bd); for (Size i=0; i<testIndex.size();i++) { Date d = testIndex[i]; Real z = hz->zeroRate(d, Period(0,Days)); Real t = hz->dayCounter().yearFraction(bd, d); if(!ii->interpolated()) // because fixing constant over period t = hz->dayCounter().yearFraction(bd, inflationPeriod(d, ii->frequency()).first); Real calc = bf * pow( 1+z, t); if (t<=0) calc = ii->fixing(d,false); // still historical if (std::fabs(calc - ii->fixing(d,true))/10000.0 > eps) BOOST_ERROR("ZC index does not forecast correctly for date " << d << " from base date " << bd << " with fixing " << bf << ", correct: " << calc << ", fix: " << ii->fixing(d,true) << ", t " << t); } //=========================================================================================== // Test zero-inflation-indexed (i.e. cpi ratio) cashflow // just ordinary indexed cashflow with a zero inflation index Date baseDate(1, January, 2006); Date fixDate(1, August, 2014); Date payDate=UnitedKingdom().adjust(fixDate+Period(3,Months),ModifiedFollowing); boost::shared_ptr<Index> ind = boost::dynamic_pointer_cast<Index>(ii); BOOST_REQUIRE_MESSAGE(ind,"dynamic_pointer_cast to Index from InflationIndex failed"); Real notional = 1000000.0;//1m IndexedCashFlow iicf(notional,ind,baseDate,fixDate,payDate); Real correctIndexed = ii->fixing(iicf.fixingDate())/ii->fixing(iicf.baseDate()); Real calculatedIndexed = iicf.amount()/iicf.notional(); BOOST_REQUIRE_MESSAGE(std::fabs(correctIndexed - calculatedIndexed) < eps, "IndexedCashFlow indexing wrong: " << calculatedIndexed << " vs correct = " << correctIndexed); //=========================================================================================== // Test zero coupon swap // first make one ... boost::shared_ptr<ZeroInflationIndex> zii = boost::dynamic_pointer_cast<ZeroInflationIndex>(ii); BOOST_REQUIRE_MESSAGE(zii,"dynamic_pointer_cast to ZeroInflationIndex from UKRPI failed"); ZeroCouponInflationSwap nzcis(ZeroCouponInflationSwap::Payer, 1000000.0, evaluationDate, zcData[6].date, // end date = maturity calendar, bdc, dc, zcData[6].rate/100.0, // fixed rate zii, observationLag); // N.B. no coupon pricer because it is not a coupon, effect of inflation curve via // inflation curve attached to the inflation index. Handle<YieldTermStructure> hTS(nominalTS); boost::shared_ptr<PricingEngine> sppe(new DiscountingSwapEngine(hTS)); nzcis.setPricingEngine(sppe); // ... and price it, should be zero BOOST_CHECK_MESSAGE(fabs(nzcis.NPV())<0.00001,"ZCIS does not reprice to zero " << nzcis.NPV() << evaluationDate << " to " << zcData[6].date << " becoming " << nzcis.maturityDate() << " rate " << zcData[6].rate << " fixed leg " << nzcis.legNPV(0) << " indexed-predicted inflated leg " << nzcis.legNPV(1) << " discount " << nominalTS->discount(nzcis.maturityDate()) ); //=========================================================================================== // Test multiplicative seasonality in price // //Seasonality factors NOT normalized //and UKRPI is not interpolated Date trueBaseDate = inflationPeriod(hz->baseDate(), ii->frequency()).second; Date seasonallityBaseDate(31,January,trueBaseDate.year()); std::vector<Rate> seasonalityFactors(12); seasonalityFactors[0] = 1.003245; seasonalityFactors[1] = 1.000000; seasonalityFactors[2] = 0.999715; seasonalityFactors[3] = 1.000495; seasonalityFactors[4] = 1.000929; seasonalityFactors[5] = 0.998687; seasonalityFactors[6] = 0.995949; seasonalityFactors[7] = 0.994682; seasonalityFactors[8] = 0.995949; seasonalityFactors[9] = 1.000519; seasonalityFactors[10] = 1.003705; seasonalityFactors[11] = 1.004186; //Creating two different seasonality objects // boost::shared_ptr<MultiplicativePriceSeasonality> seasonality_1(new MultiplicativePriceSeasonality()); std::vector<Rate> seasonalityFactors_1(12, 1.0); seasonality_1->set(seasonallityBaseDate,Monthly,seasonalityFactors_1); boost::shared_ptr<MultiplicativePriceSeasonality> seasonality_real( new MultiplicativePriceSeasonality(seasonallityBaseDate,Monthly,seasonalityFactors)); //Testing seasonality correction when seasonality factors are = 1 // Rate fixing[] = { ii->fixing(Date(14,January ,2013),true), ii->fixing(Date(14,February ,2013),true), ii->fixing(Date(14,March ,2013),true), ii->fixing(Date(14,April ,2013),true), ii->fixing(Date(14,May ,2013),true), ii->fixing(Date(14,June ,2013),true), ii->fixing(Date(14,July ,2013),true), ii->fixing(Date(14,August ,2013),true), ii->fixing(Date(14,September,2013),true), ii->fixing(Date(14,October ,2013),true), ii->fixing(Date(14,November ,2013),true), ii->fixing(Date(14,December ,2013),true) }; hz->setSeasonality(seasonality_1); QL_REQUIRE(hz->hasSeasonality(),"[44] incorrectly believes NO seasonality correction"); Rate seasonalityFixing_1[] = { ii->fixing(Date(14,January ,2013),true), ii->fixing(Date(14,February ,2013),true), ii->fixing(Date(14,March ,2013),true), ii->fixing(Date(14,April ,2013),true), ii->fixing(Date(14,May ,2013),true), ii->fixing(Date(14,June ,2013),true), ii->fixing(Date(14,July ,2013),true), ii->fixing(Date(14,August ,2013),true), ii->fixing(Date(14,September,2013),true), ii->fixing(Date(14,October ,2013),true), ii->fixing(Date(14,November ,2013),true), ii->fixing(Date(14,December ,2013),true) }; for(int i=0;i<12;i++){ if(std::fabs(fixing[i] - seasonalityFixing_1[i]) > eps) { BOOST_ERROR("Seasonality doesn't work correctly when seasonality factors are set = 1"); } } //Testing seasonality correction when seasonality factors are different from 1 // //0.998687 is the seasonality factor corresponding to June (the base CPI curve month) // Rate expectedFixing[] = { ii->fixing(Date(14,January ,2013),true) * 1.003245/0.998687, ii->fixing(Date(14,February ,2013),true) * 1.000000/0.998687, ii->fixing(Date(14,March ,2013),true) * 0.999715/0.998687, ii->fixing(Date(14,April ,2013),true) * 1.000495/0.998687, ii->fixing(Date(14,May ,2013),true) * 1.000929/0.998687, ii->fixing(Date(14,June ,2013),true) * 0.998687/0.998687, ii->fixing(Date(14,July ,2013),true) * 0.995949/0.998687, ii->fixing(Date(14,August ,2013),true) * 0.994682/0.998687, ii->fixing(Date(14,September,2013),true) * 0.995949/0.998687, ii->fixing(Date(14,October ,2013),true) * 1.000519/0.998687, ii->fixing(Date(14,November ,2013),true) * 1.003705/0.998687, ii->fixing(Date(14,December ,2013),true) * 1.004186/0.998687 }; hz->setSeasonality(seasonality_real); Rate seasonalityFixing_real[] = { ii->fixing(Date(14,January ,2013),true), ii->fixing(Date(14,February ,2013),true), ii->fixing(Date(14,March ,2013),true), ii->fixing(Date(14,April ,2013),true), ii->fixing(Date(14,May ,2013),true), ii->fixing(Date(14,June ,2013),true), ii->fixing(Date(14,July ,2013),true), ii->fixing(Date(14,August ,2013),true), ii->fixing(Date(14,September,2013),true), ii->fixing(Date(14,October ,2013),true), ii->fixing(Date(14,November ,2013),true), ii->fixing(Date(14,December ,2013),true) }; for(int i=0;i<12;i++){ if(std::fabs(expectedFixing[i] - seasonalityFixing_real[i]) > 0.01) { BOOST_ERROR("Seasonality doesn't work correctly when considering seasonality factors != 1 " << expectedFixing[i] << " vs " << seasonalityFixing_real[i]); } } //Testing Unset function // QL_REQUIRE(hz->hasSeasonality(),"[4] incorrectly believes NO seasonality correction"); hz->setSeasonality(); QL_REQUIRE(!hz->hasSeasonality(),"[5] incorrectly believes HAS seasonality correction"); Rate seasonalityFixing_unset[] = { ii->fixing(Date(14,January ,2013),true), ii->fixing(Date(14,February ,2013),true), ii->fixing(Date(14,March ,2013),true), ii->fixing(Date(14,April ,2013),true), ii->fixing(Date(14,May ,2013),true), ii->fixing(Date(14,June ,2013),true), ii->fixing(Date(14,July ,2013),true), ii->fixing(Date(14,August ,2013),true), ii->fixing(Date(14,September,2013),true), ii->fixing(Date(14,October ,2013),true), ii->fixing(Date(14,November ,2013),true), ii->fixing(Date(14,December ,2013),true) }; for(int i=0;i<12;i++){ if(std::fabs(seasonalityFixing_unset[i] - seasonalityFixing_1[i]) > eps) { BOOST_ERROR("UnsetSeasonality doesn't work correctly " << seasonalityFixing_unset[i] << " vs " << seasonalityFixing_1[i]); } } //============================================================================== // now do an INTERPOLATED index, i.e. repeat everything on a fake version of // UKRPI (to save making another term structure) bool interpYES = true; boost::shared_ptr<UKRPI> iiUKRPIyes(new UKRPI(interpYES, hz)); for (Size i=0; i<rpiSchedule.size();i++) { iiUKRPIyes->addFixing(rpiSchedule[i], fixData[i]); } boost::shared_ptr<ZeroInflationIndex> iiyes = boost::dynamic_pointer_cast<ZeroInflationIndex>(iiUKRPIyes); // now build the zero inflation curve // same data, bigger lag or it will be a self-contradiction Period observationLagyes = Period(3,Months); std::vector<boost::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > > helpersyes = makeHelpers<ZeroInflationTermStructure,ZeroCouponInflationSwapHelper, ZeroInflationIndex>(zcData, LENGTH(zcData), iiyes, observationLagyes, calendar, bdc, dc); boost::shared_ptr<PiecewiseZeroInflationCurve<Linear> > pZITSyes( new PiecewiseZeroInflationCurve<Linear>( evaluationDate, calendar, dc, observationLagyes, frequency, iiyes->interpolated(), baseZeroRate, Handle<YieldTermStructure>(nominalTS), helpersyes)); pZITSyes->recalculate(); // first check that the zero rates on the curve match the data // and that the helpers give the correct impled rates forceLinearInterpolation = false; // still for (Size i=0; i<LENGTH(zcData); i++) { BOOST_CHECK_MESSAGE(std::fabs(zcData[i].rate/100.0 - pZITSyes->zeroRate(zcData[i].date, observationLagyes, forceLinearInterpolation)) < eps, "ZITS INTERPOLATED zeroRate != instrument " << pZITSyes->zeroRate(zcData[i].date, observationLagyes, forceLinearInterpolation) << " date " << zcData[i].date << " observationLagyes " << observationLagyes << " vs " << zcData[i].rate/100.0 << " interpolation: " << iiyes->interpolated() << " forceLinearInterpolation " << forceLinearInterpolation); BOOST_CHECK_MESSAGE(std::fabs(helpersyes[i]->impliedQuote() - zcData[i].rate/100.0) < eps, "ZITS INTERPOLATED implied quote != instrument " << helpersyes[i]->impliedQuote() << " vs " << zcData[i].rate/100.0); } //====================================================================================== // now test the forecasting capability of the index. hz.linkTo(pZITSyes); from = hz->baseDate()+1*Months; // to avoid historical linear bit for rest of base month to = hz->maxDate()-1*Months; // a bit of margin for adjustments testIndex = MakeSchedule().from(from).to(to) .withTenor(1*Months) .withCalendar(UnitedKingdom()) .withConvention(ModifiedFollowing); // we are testing UKRPI which is FAKE interpolated for testing here bd = hz->baseDate(); bf = iiyes->fixing(bd); for (Size i=0; i<testIndex.size();i++) { Date d = testIndex[i]; Real z = hz->zeroRate(d, Period(0,Days)); Real t = hz->dayCounter().yearFraction(bd, d); Real calc = bf * pow( 1+z, t); if (t<=0) calc = iiyes->fixing(d); // still historical if (std::fabs(calc - iiyes->fixing(d)) > eps) BOOST_ERROR("ZC INTERPOLATED index does not forecast correctly for date " << d << " from base date " << bd << " with fixing " << bf << ", correct: " << calc << ", fix: " << iiyes->fixing(d) << ", t " << t << ", zero " << z); } //=========================================================================================== // Test zero coupon swap boost::shared_ptr<ZeroInflationIndex> ziiyes = boost::dynamic_pointer_cast<ZeroInflationIndex>(iiyes); BOOST_REQUIRE_MESSAGE(ziiyes,"dynamic_pointer_cast to ZeroInflationIndex from UKRPI-I failed"); ZeroCouponInflationSwap nzcisyes(ZeroCouponInflationSwap::Payer, 1000000.0, evaluationDate, zcData[6].date, // end date = maturity calendar, bdc, dc, zcData[6].rate/100.0, // fixed rate ziiyes, observationLagyes); // N.B. no coupon pricer because it is not a coupon, effect of inflation curve via // inflation curve attached to the inflation index. nzcisyes.setPricingEngine(sppe); // ... and price it, should be zero BOOST_CHECK_MESSAGE(fabs(nzcisyes.NPV())<0.00001,"ZCIS-I does not reprice to zero " << nzcisyes.NPV() << evaluationDate << " to " << zcData[6].date << " becoming " << nzcisyes.maturityDate() << " rate " << zcData[6].rate << " fixed leg " << nzcisyes.legNPV(0) << " indexed-predicted inflated leg " << nzcisyes.legNPV(1) << " discount " << nominalTS->discount(nzcisyes.maturityDate()) ); }
/* Generally inflation indices are available with a lag of 1month and then observed with a lag of 2-3 months depending whether they use an interpolated fixing or not. Here, we make the swap use the interpolation of the index to avoid incompatibilities. */ ZeroCouponInflationSwap::ZeroCouponInflationSwap( Type type, Real nominal, const Date& startDate, // start date of contract (only) const Date& maturity, // this is pre-adjustment! const Calendar& fixCalendar, BusinessDayConvention fixConvention, const DayCounter& dayCounter, Rate fixedRate, const boost::shared_ptr<ZeroInflationIndex> &infIndex, const Period& observationLag, bool adjustInfObsDates, Calendar infCalendar, BusinessDayConvention infConvention) : Swap(2), type_(type), nominal_(nominal), fixedRate_(fixedRate), infIndex_(infIndex), observationLag_(observationLag), dayCounter_(dayCounter) { // first check compatibility of index and swap definitions if (infIndex_->interpolated()) { Period pShift(infIndex_->frequency()); QL_REQUIRE(observationLag_ - pShift > infIndex_->availabilityLag(), "inconsistency between swap observation of index " << observationLag_ << " index availability " << infIndex_->availabilityLag() << " interpolated index period " << pShift << " and index availability " << infIndex_->availabilityLag() << " need (obsLag-index period) > availLag"); } else { QL_REQUIRE(infIndex_->availabilityLag() < observationLag_, "index tries to observe inflation fixings that do not yet exist: " << " availability lag " << infIndex_->availabilityLag() << " versus obs lag = " << observationLag_); } if (infCalendar==Calendar()) infCalendar = fixCalendar; if (infConvention==BusinessDayConvention()) infConvention = fixConvention; if (adjustInfObsDates) { baseDate_ = infCalendar.adjust(startDate - observationLag_, infConvention); obsDate_ = infCalendar.adjust(maturity - observationLag_, infConvention); } else { baseDate_ = startDate - observationLag_; obsDate_ = maturity - observationLag_; } Date infPayDate = infCalendar.adjust(maturity, infConvention); Date fixedPayDate = fixCalendar.adjust(maturity, fixConvention); // At this point the index may not be able to forecast // i.e. do not want to force the existence of an inflation // term structure before allowing users to create instruments. Real T = inflationYearFraction(infIndex_->frequency(), infIndex_->interpolated(), dayCounter_, baseDate_, obsDate_); // N.B. the -1.0 is because swaps only exchange growth, not notionals as well Real fixedAmount = nominal * ( std::pow(1.0 + fixedRate, T) - 1.0 ); legs_[0].push_back(boost::shared_ptr<CashFlow>( new SimpleCashFlow(fixedAmount, fixedPayDate))); bool growthOnly = true; legs_[1].push_back(boost::shared_ptr<CashFlow>( new IndexedCashFlow(nominal,infIndex,baseDate_,obsDate_,infPayDate,growthOnly))); for (Size j=0; j<2; ++j) { for (Leg::iterator i = legs_[j].begin(); i!= legs_[j].end(); ++i) registerWith(*i); } switch (type_) { case Payer: payer_[0] = +1.0; payer_[1] = -1.0; break; case Receiver: payer_[0] = -1.0; payer_[1] = +1.0; break; default: QL_FAIL("Unknown zero-inflation-swap type"); } }
CPILeg::operator Leg() const { QL_REQUIRE(!notionals_.empty(), "no notional given"); Size n = schedule_.size()-1; Calendar calendar = schedule_.calendar(); Leg leg; leg.reserve(n+1); // +1 for notional, we always have some sort ... if (n>0) { QL_REQUIRE(!fixedRates_.empty() || !spreads_.empty(), "no fixedRates or spreads given"); Date refStart, start, refEnd, end; for (Size i=0; i<n; ++i) { refStart = start = schedule_.date(i); refEnd = end = schedule_.date(i+1); Date paymentDate = calendar.adjust(end, paymentAdjustment_); if (i==0 && !schedule_.isRegular(i+1)) { BusinessDayConvention bdc = schedule_.businessDayConvention(); refStart = schedule_.calendar().adjust(end - schedule_.tenor(), bdc); } if (i==n-1 && !schedule_.isRegular(i+1)) { BusinessDayConvention bdc = schedule_.businessDayConvention(); refEnd = schedule_.calendar().adjust(start + schedule_.tenor(), bdc); } if (detail::get(fixedRates_, i, 1.0) == 0.0) { // fixed coupon leg.push_back(boost::shared_ptr<CashFlow> (new FixedRateCoupon (paymentDate, detail::get(notionals_, i, 0.0), detail::effectiveFixedRate(spreads_,caps_,floors_,i), paymentDayCounter_, start, end, refStart, refEnd))); } else { // zero inflation coupon if (detail::noOption(caps_, floors_, i)) { // just swaplet boost::shared_ptr<CPICoupon> coup; coup = boost::shared_ptr<CPICoupon> (new CPICoupon(baseCPI_, // all have same base for ratio paymentDate, detail::get(notionals_, i, 0.0), start, end, detail::get(fixingDays_, i, 0.0), index_, observationLag_, observationInterpolation_, paymentDayCounter_, detail::get(fixedRates_, i, 0.0), detail::get(spreads_, i, 0.0), refStart, refEnd)); // in this case you can set a pricer // straight away because it only provides computation - not data boost::shared_ptr<CPICouponPricer> pricer (new CPICouponPricer); coup->setPricer(pricer); leg.push_back(boost::dynamic_pointer_cast<CashFlow>(coup)); } else { // cap/floorlet QL_FAIL("caps/floors on CPI coupons not implemented."); } } } } // in CPI legs you always have a notional flow of some sort Date paymentDate = calendar.adjust(schedule_.date(n), paymentAdjustment_); Date fixingDate = paymentDate - observationLag_; boost::shared_ptr<CashFlow> xnl(new CPICashFlow (detail::get(notionals_, n, 0.0), index_, Date(), // is fake, i.e. you do not have one baseCPI_, fixingDate, paymentDate, subtractInflationNominal_, observationInterpolation_, index_->frequency()) ); leg.push_back(xnl); return leg; }
void CreditDefaultSwapTest::testImpliedHazardRate() { BOOST_TEST_MESSAGE("Testing implied hazard-rate for credit-default swaps..."); SavedSettings backup; // Initialize curves Calendar calendar = TARGET(); Date today = calendar.adjust(Date::todaysDate()); Settings::instance().evaluationDate() = today; Rate h1 = 0.30, h2 = 0.40; DayCounter dayCounter = Actual365Fixed(); std::vector<Date> dates(3); std::vector<Real> hazardRates(3); dates[0] = today; hazardRates[0] = h1; dates[1] = today + 5*Years; hazardRates[1] = h1; dates[2] = today + 10*Years; hazardRates[2] = h2; RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve; probabilityCurve.linkTo(ext::shared_ptr<DefaultProbabilityTermStructure>( new InterpolatedHazardRateCurve<BackwardFlat>(dates, hazardRates, dayCounter))); RelinkableHandle<YieldTermStructure> discountCurve; discountCurve.linkTo(ext::shared_ptr<YieldTermStructure>( new FlatForward(today,0.03,Actual360()))); Frequency frequency = Semiannual; BusinessDayConvention convention = ModifiedFollowing; Date issueDate = calendar.advance(today, -6, Months); Rate fixedRate = 0.0120; DayCounter cdsDayCount = Actual360(); Real notional = 10000.0; Real recoveryRate = 0.4; Rate latestRate = Null<Rate>(); for (Integer n=6; n<=10; ++n) { Date maturity = calendar.advance(issueDate, n, Years); Schedule schedule(issueDate, maturity, Period(frequency), calendar, convention, convention, DateGeneration::Forward, false); CreditDefaultSwap cds(Protection::Seller, notional, fixedRate, schedule, convention, cdsDayCount, true, true); cds.setPricingEngine(ext::shared_ptr<PricingEngine>( new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve))); Real NPV = cds.NPV(); Rate flatRate = cds.impliedHazardRate(NPV, discountCurve, dayCounter, recoveryRate); if (flatRate < h1 || flatRate > h2) { BOOST_ERROR("implied hazard rate outside expected range\n" << " maturity: " << n << " years\n" << " expected minimum: " << h1 << "\n" << " expected maximum: " << h2 << "\n" << " implied rate: " << flatRate); } if (n > 6 && flatRate < latestRate) { BOOST_ERROR("implied hazard rate decreasing with swap maturity\n" << " maturity: " << n << " years\n" << " previous rate: " << latestRate << "\n" << " implied rate: " << flatRate); } latestRate = flatRate; RelinkableHandle<DefaultProbabilityTermStructure> probability; probability.linkTo(ext::shared_ptr<DefaultProbabilityTermStructure>( new FlatHazardRate( today, Handle<Quote>(ext::shared_ptr<Quote>(new SimpleQuote(flatRate))), dayCounter))); CreditDefaultSwap cds2(Protection::Seller, notional, fixedRate, schedule, convention, cdsDayCount, true, true); cds2.setPricingEngine(ext::shared_ptr<PricingEngine>( new MidPointCdsEngine(probability,recoveryRate, discountCurve))); Real NPV2 = cds2.NPV(); Real tolerance = 1.0; if (std::fabs(NPV-NPV2) > tolerance) { BOOST_ERROR("failed to reproduce NPV with implied rate\n" << " expected: " << NPV << "\n" << " calculated: " << NPV2); } } }