// [[Rcpp::export]]
Rcpp::List affineWithRebuiltCurveEngine(Rcpp::List rparam,
Rcpp::List legparams,
std::vector<QuantLib::Date> dateVec,
std::vector<double> zeroVec,
Rcpp::NumericVector swaptionMat,
Rcpp::NumericVector swapLengths,
Rcpp::NumericVector swaptionVols) {
// std::vector<std::string> tsnames = tslist.names();
QuantLib::Size i;
//int *swaptionMat=0, *swapLengths=0;
//double **swaptionVols=0;
double notional = 10000; // prices in basis points
QuantLib::Date todaysDate(Rcpp::as<QuantLib::Date>(rparam["tradeDate"]));
QuantLib::Date settlementDate(Rcpp::as<QuantLib::Date>(rparam["settleDate"]));
QuantLib::Date startDate(Rcpp::as<QuantLib::Date>(rparam["startDate"]));
QuantLib::Date maturity(Rcpp::as<QuantLib::Date>(rparam["maturity"]));
bool payfix = Rcpp::as<bool>(rparam["payFixed"]);
bool european = Rcpp::as<bool>(rparam["european"]);
//cout << "TradeDate: " << todaysDate << endl << "Settle: " << settlementDate << endl;
RQLContext::instance().settleDate = settlementDate;
QuantLib::Settings::instance().evaluationDate() = todaysDate;
// initialise from the singleton instance
QuantLib::Calendar calendar = RQLContext::instance().calendar;
//Integer fixingDays = RQLContext::instance().fixingDays;
double strike = Rcpp::as<double>(rparam["strike"]);
std::string method = Rcpp::as<std::string>(rparam["method"]);
QuantLib::Handle<QuantLib::YieldTermStructure>
rhTermStructure(rebuildCurveFromZeroRates(dateVec, zeroVec));
// Get swaption maturities
//Rcpp::NumericVector swaptionMat(maturities);
int numRows = swaptionMat.size();
// Create dummy swap to get schedules.
QuantLib::Frequency fixedLegFrequency = getFrequency(Rcpp::as<double>(legparams["fixFreq"]));
QuantLib::BusinessDayConvention fixedLegConvention = QuantLib::Unadjusted;
QuantLib::BusinessDayConvention floatingLegConvention = QuantLib::ModifiedFollowing;
QuantLib::DayCounter swFixedLegDayCounter = getDayCounter(Rcpp::as<double>(legparams["dayCounter"]));
boost::shared_ptr<QuantLib::IborIndex> swFloatingLegIndex(new QuantLib::Euribor(QuantLib::Period(Rcpp::as<int>(legparams["floatFreq"]),QuantLib::Months),rhTermStructure));
QuantLib::Rate dummyFixedRate = 0.03;
QuantLib::Schedule fixedSchedule(startDate,maturity,
QuantLib::Period(fixedLegFrequency),calendar,
fixedLegConvention,fixedLegConvention,
QuantLib::DateGeneration::Forward,false);
QuantLib::Schedule floatSchedule(startDate,maturity,QuantLib::Period(Rcpp::as<int>(legparams["floatFreq"]),QuantLib::Months),
calendar,
floatingLegConvention,floatingLegConvention,
QuantLib::DateGeneration::Forward,false);
QuantLib::VanillaSwap::Type type;
if(payfix){
type = QuantLib::VanillaSwap::Payer;}
else{
type = QuantLib::VanillaSwap::Receiver;
}
boost::shared_ptr<QuantLib::VanillaSwap>
swap(new QuantLib::VanillaSwap(type, notional,
fixedSchedule, dummyFixedRate, swFixedLegDayCounter,
floatSchedule, swFloatingLegIndex, 0.0,
swFloatingLegIndex->dayCounter()));
swap->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(new QuantLib::DiscountingSwapEngine(rhTermStructure)));
// Find the ATM or break-even rate
QuantLib::Rate fixedATMRate = swap->fairRate();
QuantLib::Rate fixedRate;
if(strike < 0) // factor instead of real strike
fixedRate = fixedATMRate * (-strike);
else
fixedRate = strike;
// The swap underlying the Affine swaption.
boost::shared_ptr<QuantLib::VanillaSwap>
mySwap(new QuantLib::VanillaSwap(type, notional,
fixedSchedule, fixedRate,swFixedLegDayCounter,
floatSchedule, swFloatingLegIndex, 0.0,
swFloatingLegIndex->dayCounter()));
swap->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(new QuantLib::DiscountingSwapEngine(rhTermStructure)));
// Build swaptions that will be used to calibrate model to
// the volatility matrix.
std::vector<QuantLib::Period> swaptionMaturities;
for(i = 0; i < (QuantLib::Size)numRows; i++)
swaptionMaturities.push_back(QuantLib::Period(swaptionMat[i], QuantLib::Years));
// Swaptions used for calibration
std::vector<boost::shared_ptr<QuantLib::BlackCalibrationHelper> > swaptions;
// List of times that have to be included in the timegrid
std::list<QuantLib::Time> times;
for (i=0; i<(QuantLib::Size)numRows; i++) {
//boost::shared_ptr<QuantLib::Quote> vol(new QuantLib::SimpleQuote(swaptionVols[i][numCols-i-1]));
boost::shared_ptr<QuantLib::Quote> vol(new QuantLib::SimpleQuote(swaptionVols(i)));
swaptions.push_back(boost::shared_ptr<QuantLib::BlackCalibrationHelper>(new QuantLib::SwaptionHelper(swaptionMaturities[i],
QuantLib::Period(swapLengths[i], QuantLib::Years),
QuantLib::Handle<QuantLib::Quote>(vol),
swFloatingLegIndex,
swFloatingLegIndex->tenor(),
swFloatingLegIndex->dayCounter(),
swFloatingLegIndex->dayCounter(),
rhTermStructure)));
swaptions.back()->addTimesTo(times);
}
// Building time-grid
QuantLib::TimeGrid grid(times.begin(), times.end(), 30);
// Get Affine swaption exercise dates, single date if europen, coupon dates if bermudan
std::vector<QuantLib::Date> affineDates;
const std::vector<boost::shared_ptr<QuantLib::CashFlow> >& leg = swap->fixedLeg();
if(european){
boost::shared_ptr<QuantLib::Coupon> coupon = boost::dynamic_pointer_cast<QuantLib::Coupon>(leg[0]);
affineDates.push_back(coupon->accrualStartDate());
} else{
for (i=0; i<leg.size(); i++) {
boost::shared_ptr<QuantLib::Coupon> coupon = boost::dynamic_pointer_cast<QuantLib::Coupon>(leg[i]);
affineDates.push_back(coupon->accrualStartDate());
}
}
boost::shared_ptr<QuantLib::Exercise> affineExercise(new QuantLib::BermudanExercise(affineDates));
// Price based on method selected.
if (method.compare("G2Analytic") == 0) {
boost::shared_ptr<QuantLib::G2> modelG2(new QuantLib::G2(rhTermStructure));
Rprintf((char*)"G2/Jamshidian (analytic) calibration\n");
for(i = 0; i < swaptions.size(); i++)
swaptions[i]->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(new QuantLib::G2SwaptionEngine(modelG2, 6.0, 16)));
calibrateModel2(modelG2, swaptions, 0.05, swaptionMat, swapLengths, swaptionVols);
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::TreeSwaptionEngine(modelG2, 50));
QuantLib::Swaption affineSwaption(mySwap, affineExercise);
affineSwaption.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("a") = modelG2->params()[0],
Rcpp::Named("sigma") = modelG2->params()[1],
Rcpp::Named("b") = modelG2->params()[2],
Rcpp::Named("eta") = modelG2->params()[3],
Rcpp::Named("rho") = modelG2->params()[4],
Rcpp::Named("NPV") = affineSwaption.NPV(),
Rcpp::Named("ATMStrike") = fixedATMRate);
//Rcpp::Named("params") = params);
} else if (method.compare("HWAnalytic") == 0) {
boost::shared_ptr<QuantLib::HullWhite> modelHW(new QuantLib::HullWhite(rhTermStructure));
Rprintf((char*)"Hull-White (analytic) calibration\n");
for (i=0; i<swaptions.size(); i++)
swaptions[i]->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(new QuantLib::JamshidianSwaptionEngine(modelHW)));
calibrateModel2(modelHW, swaptions, 0.05, swaptionMat, swapLengths, swaptionVols);
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::TreeSwaptionEngine(modelHW, 50));
QuantLib::Swaption affineSwaption(mySwap, affineExercise);
affineSwaption.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("a") = modelHW->params()[0],
Rcpp::Named("sigma") = modelHW->params()[1],
Rcpp::Named("NPV") = affineSwaption.NPV(),
Rcpp::Named("ATMStrike") = fixedATMRate);
//Rcpp::Named("params") = params);
} else if (method.compare("HWTree") == 0) {
boost::shared_ptr<QuantLib::HullWhite> modelHW2(new QuantLib::HullWhite(rhTermStructure));
Rprintf((char*)"Hull-White (tree) calibration\n");
for (i=0; i<swaptions.size(); i++)
swaptions[i]->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(new QuantLib::TreeSwaptionEngine(modelHW2,grid)));
calibrateModel2(modelHW2, swaptions, 0.05, swaptionMat, swapLengths, swaptionVols);
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::TreeSwaptionEngine(modelHW2, 50));
QuantLib::Swaption affineSwaption(mySwap, affineExercise);
affineSwaption.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("a") = modelHW2->params()[0],
Rcpp::Named("sigma") = modelHW2->params()[1],
Rcpp::Named("NPV") = affineSwaption.NPV(),
Rcpp::Named("ATMStrike") = fixedATMRate);
//Rcpp::Named("params") = params);
} else if (method.compare("BKTree") == 0) {
boost::shared_ptr<QuantLib::BlackKarasinski> modelBK(new QuantLib::BlackKarasinski(rhTermStructure));
Rprintf((char*)"Black-Karasinski (tree) calibration\n");
for (i=0; i<swaptions.size(); i++)
swaptions[i]->setPricingEngine(boost::shared_ptr<QuantLib::PricingEngine>(new QuantLib::TreeSwaptionEngine(modelBK,grid)));
calibrateModel2(modelBK, swaptions, 0.05, swaptionMat, swapLengths, swaptionVols);
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::TreeSwaptionEngine(modelBK, 50));
QuantLib::Swaption affineSwaption(mySwap, affineExercise);
affineSwaption.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("a") = modelBK->params()[0],
Rcpp::Named("sigma") = modelBK->params()[1],
Rcpp::Named("price") = affineSwaption.NPV(),
Rcpp::Named("ATMStrike") = fixedATMRate);
//Rcpp::Named("params") = params);
} else {
throw std::range_error("Unknown method in AffineSwaption\n");
}
}
// Get RateHelper used to build the yield curve corresponding to a
// database key ('ticker') and observed rate/price.
boost::shared_ptr<QuantLib::RateHelper>
ObservableDB::getRateHelper(std::string& ticker, QuantLib::Rate r) {
RQLMapIterator iter = db_.find(ticker);
if (iter == db_.end()) {
std::string errortxt = "Unknown curve construction instrument: " + ticker;
Rcpp::stop(errortxt);
}
RQLObservable *p = iter->second;
RQLObservableType type = p->getType();
int n1 = p->getN1(), n2 = p->getN2();
QuantLib::TimeUnit units = p->getUnits();
QuantLib::Date settlementDate = RQLContext::instance().settleDate;
QuantLib::Calendar calendar = RQLContext::instance().calendar;
QuantLib::Integer fixingDays = RQLContext::instance().fixingDays;
QuantLib::DayCounter depositDayCounter = QuantLib::Actual360();
// Tried to use a switch statement here, but there was an
// internal compiler error using g++ Version 3.2.2.
if (type == RQLDeposit) {
boost::shared_ptr<QuantLib::Quote> quote(new QuantLib::SimpleQuote(r));
boost::shared_ptr<QuantLib::RateHelper>
depo(new QuantLib::DepositRateHelper(QuantLib::Handle<QuantLib::Quote>(quote),
n1*units, fixingDays,
calendar, QuantLib::ModifiedFollowing,
true, /*fixingDays,*/ depositDayCounter));
return depo;
} else if (type == RQLSwap) {
QuantLib::Frequency swFixedLegFrequency = QuantLib::Annual;
QuantLib::BusinessDayConvention swFixedLegConvention = QuantLib::Unadjusted;
QuantLib::DayCounter swFixedLegDayCounter = QuantLib::Thirty360(QuantLib::Thirty360::European);
boost::shared_ptr<QuantLib::IborIndex> swFloatingLegIndex(new QuantLib::Euribor6M);
boost::shared_ptr<QuantLib::Quote> quote(new QuantLib::SimpleQuote(r));
boost::shared_ptr<QuantLib::RateHelper>
swap(new QuantLib::SwapRateHelper(QuantLib::Handle<QuantLib::Quote>(quote),
n1*QuantLib::Years, /*fixingDays,*/
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex));
return swap;
} else if (type == RQLFuture) {
QuantLib::Integer futMonths = 3;
QuantLib::Date imm = QuantLib::IMM::nextDate(settlementDate);
for (int i = 1; i < n1; i++)
imm = QuantLib::IMM::nextDate(imm+1);
//Rcpp::Rcout << "Curves: IMM Date is " << imm << std::endl;
boost::shared_ptr<QuantLib::Quote> quote(new QuantLib::SimpleQuote(r));
boost::shared_ptr<QuantLib::RateHelper>
future(new QuantLib::FuturesRateHelper(QuantLib::Handle<QuantLib::Quote>(quote),
imm, futMonths, calendar,
QuantLib::ModifiedFollowing,
true, // added bool endOfMonth variable
depositDayCounter));
return future;
} else if (type == RQLFRA) {
boost::shared_ptr<QuantLib::Quote> quote(new QuantLib::SimpleQuote(r));
boost::shared_ptr<QuantLib::RateHelper>
FRA(new QuantLib::FraRateHelper(QuantLib::Handle<QuantLib::Quote>(quote),
n1, n2, fixingDays, calendar,
QuantLib::ModifiedFollowing,
true, /*fixingDays,*/ depositDayCounter));
return FRA;
} else {
Rcpp::stop("Bad type in curve construction");
}
// not reached
boost::shared_ptr<QuantLib::RateHelper> tmp;
return tmp;
}
