VanillaSwap::VanillaSwap(
const shared_ptr<ObjectHandler::ValueObject>& properties,
const QuantLib::Period& swapTenor,
const shared_ptr<QuantLib::IborIndex>& index,
QuantLib::Rate fixedRate,
const QuantLib::Date& immDate,
const QuantLib::DayCounter& fixDayCounter,
QuantLib::Spread floatingLegSpread,
bool permanent)
: Swap(properties, permanent)
{
QuantLib::Date effectiveDate = immDate;
if (effectiveDate==QuantLib::Date())
effectiveDate = QuantLib::IMM::nextDate();
QuantLib::Date terminationDate = effectiveDate+swapTenor;
terminationDate = QuantLib::Date::nthWeekday(3,
QuantLib::Wednesday,
terminationDate.month(),
terminationDate.year());
libraryObject_ = MakeVanillaSwap(swapTenor, index,
fixedRate)
.withEffectiveDate(effectiveDate)
.withTerminationDate(terminationDate)
.withRule(QuantLib::DateGeneration::ThirdWednesday)
.withFixedLegDayCount(fixDayCounter)
.withFloatingLegSpread(floatingLegSpread)
.operator shared_ptr<QuantLib::VanillaSwap>();
}
// [[Rcpp::export]]
Rcpp::List europeanOptionArraysEngine(std::string type, Rcpp::NumericMatrix par) {
QuantLib::Option::Type optionType = getOptionType(type);
int n = par.nrow();
Rcpp::NumericVector value(n), delta(n), gamma(n), vega(n), theta(n), rho(n), divrho(n);
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
for (int i=0; i<n; i++) {
double underlying = par(i, 0); // first column
double strike = par(i, 1); // second column
QuantLib::Spread dividendYield = par(i, 2); // third column
QuantLib::Rate riskFreeRate = par(i, 3); // fourth column
QuantLib::Time maturity = par(i, 4); // fifth column
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better
#endif
double volatility = par(i, 5); // sixth column
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote( underlying ));
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote( volatility ));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote( dividendYield ));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote( riskFreeRate ));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
boost::shared_ptr<QuantLib::VanillaOption> option = makeOption(payoff, exercise, spot, qTS, rTS, volTS);
value[i] = option->NPV();
delta[i] = option->delta();
gamma[i] = option->gamma();
vega[i] = option->vega();
theta[i] = option->theta();
rho[i] = option->rho();
divrho[i] = option->dividendRho();
}
return Rcpp::List::create(Rcpp::Named("value") = value,
Rcpp::Named("delta") = delta,
Rcpp::Named("gamma") = gamma,
Rcpp::Named("vega") = vega,
Rcpp::Named("theta") = theta,
Rcpp::Named("rho") = rho,
Rcpp::Named("divRho") = divrho);
}
// dumped core when we tried last
// no longer under 0.3.10 and g++ 4.0.1 (Aug 2005)
// [[Rcpp::export]]
double binaryOptionImpliedVolatilityEngine(std::string type,
double value,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double cashPayoff) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(maturity * 360 * 24 * 60);
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Option::Type optionType = getOptionType(type);
// updated again for QuantLib 0.9.0,
// cf QuantLib-0.9.0/test-suite/digitaloption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::StrikedTypePayoff>
payoff(new QuantLib::CashOrNothingPayoff(optionType, strike, cashPayoff));
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
//boost::shared_ptr<PricingEngine> engine(new AnalyticEuropeanEngine(stochProcess));
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::AnalyticBarrierEngine(stochProcess));
QuantLib::VanillaOption opt(payoff, exercise);
opt.setPricingEngine(engine);
return opt.impliedVolatility(value, stochProcess);
}
// [[Rcpp::export]]
bool setCalendarContext(std::string calendar, int fixingDays, QuantLib::Date settleDate) {
// Rcpp Attribute cannot reflect complicated default arguments
if (settleDate.serialNumber() == 0) {
calendar = "TARGET";
fixingDays = 2;
settleDate = QuantLib::Date::todaysDate() + 2;
}
// set fixingDays and settleDate
RQLContext::instance().fixingDays = fixingDays;
RQLContext::instance().settleDate = settleDate;
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
RQLContext::instance().calendar = *pcal; // set calendar in global singleton
return true;
}
long libraryToScalar(const QuantLib::Date &d) {
return d.serialNumber();
}
// [[Rcpp::export]]
Rcpp::List binaryOptionEngine(std::string binType,
std::string type,
std::string excType,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double cashPayoff) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(maturity * 360 * 24 * 60);
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better, but same rounding in QL
#endif
QuantLib::Option::Type optionType = getOptionType(type);
// new QuantLib 0.3.5 framework: digitals, updated for 0.3.7
// updated again for QuantLib 0.9.0,
// cf QuantLib-0.9.0/test-suite/digitaloption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today,qRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today,rRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff;
if (binType=="cash") {
boost::shared_ptr<QuantLib::StrikedTypePayoff> con(new QuantLib::CashOrNothingPayoff(optionType, strike, cashPayoff));
payoff = con;
} else if (binType=="asset") {
boost::shared_ptr<QuantLib::StrikedTypePayoff> aon(new QuantLib::AssetOrNothingPayoff(optionType, strike));
payoff = aon;
} else if (binType=="gap") {
boost::shared_ptr<QuantLib::StrikedTypePayoff> gap(new QuantLib::GapPayoff(optionType, strike, cashPayoff));
payoff = gap;
} else {
throw std::range_error("Unknown binary option type " + binType);
}
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise;
if (excType=="american") {
boost::shared_ptr<QuantLib::Exercise> amEx(new QuantLib::AmericanExercise(today, exDate));
exercise = amEx;
} else if (excType=="european") {
boost::shared_ptr<QuantLib::Exercise> euEx(new QuantLib::EuropeanExercise(exDate));
exercise = euEx;
} else {
throw std::range_error("Unknown binary exercise type " + excType);
}
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
boost::shared_ptr<QuantLib::PricingEngine> engine;
if (excType=="american") {
boost::shared_ptr<QuantLib::PricingEngine> amEng(new QuantLib::AnalyticDigitalAmericanEngine(stochProcess));
engine = amEng;
} else if (excType=="european") {
boost::shared_ptr<QuantLib::PricingEngine> euEng(new QuantLib::AnalyticEuropeanEngine(stochProcess));
engine = euEng;
} else {
throw std::range_error("Unknown binary exercise type " + excType);
}
QuantLib::VanillaOption opt(payoff, exercise);
opt.setPricingEngine(engine);
Rcpp::List rl = Rcpp::List::create(Rcpp::Named("value") = opt.NPV(),
Rcpp::Named("delta") = opt.delta(),
Rcpp::Named("gamma") = opt.gamma(),
Rcpp::Named("vega") = (excType=="european") ? opt.vega() : R_NaN,
Rcpp::Named("theta") = (excType=="european") ? opt.theta() : R_NaN,
Rcpp::Named("rho") = (excType=="european") ? opt.rho() : R_NaN,
Rcpp::Named("divRho") = (excType=="european") ? opt.dividendRho() : R_NaN);
return rl;
}
// [[Rcpp::export]]
Rcpp::List barrierOptionEngine(std::string barrType,
std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double barrier,
double rebate) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(maturity * 360 * 24 * 60);
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Barrier::Type barrierType = QuantLib::Barrier::DownIn;
if (barrType=="downin") {
barrierType = QuantLib::Barrier::DownIn;
} else if (barrType=="upin") {
barrierType = QuantLib::Barrier::UpIn;
} else if (barrType=="downout") {
barrierType = QuantLib::Barrier::DownOut;
} else if (barrType=="upout") {
barrierType = QuantLib::Barrier::UpOut;
} else {
throw std::range_error("Unknown barrier type " + type);
}
QuantLib::Option::Type optionType = getOptionType(type);
// new QuantLib 0.3.5 framework, updated for 0.3.7
// updated again for QuantLib 0.9.0,
// cf QuantLib-0.9.0/test-suite/barrieroption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today,rRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
// Size timeSteps = 1;
// bool antitheticVariate = false;
// bool controlVariate = false;
// Size requiredSamples = 10000;
// double requiredTolerance = 0.02;
// Size maxSamples = 1000000;
// bool isBiased = false;
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::AnalyticBarrierEngine(stochProcess));
// need to explicitly reference BarrierOption from QuantLib here
QuantLib::BarrierOption barrierOption(barrierType,
barrier,
rebate,
payoff,
exercise);
barrierOption.setPricingEngine(engine);
Rcpp::List rl = Rcpp::List::create(Rcpp::Named("value") = barrierOption.NPV(),
Rcpp::Named("delta") = R_NaReal,
Rcpp::Named("gamma") = R_NaReal,
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
return rl;
}
// [[Rcpp::export]]
Rcpp::List asianOptionEngine(std::string averageType,
std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double first,
double length,
size_t fixings) {
QuantLib::Option::Type optionType = getOptionType(type);
//from test-suite/asionoptions.cpp
QuantLib::DayCounter dc = QuantLib::Actual360();
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::ext::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
QuantLib::ext::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
QuantLib::ext::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
QuantLib::ext::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
QuantLib::ext::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
QuantLib::ext::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
QuantLib::ext::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
QuantLib::ext::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new
QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
QuantLib::ext::shared_ptr<QuantLib::StrikedTypePayoff>
payoff(new QuantLib::PlainVanillaPayoff(optionType,strike));
Rcpp::List rl = R_NilValue;
if (averageType=="geometric"){
QuantLib::ext::shared_ptr<QuantLib::PricingEngine>
engine(new
QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine(stochProcess));
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
QuantLib::Date exDate(today.dateTime() + boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60)));
#else
QuantLib::Date exDate = today + int(maturity * 360 + 0.5);
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
QuantLib::ContinuousAveragingAsianOption option(QuantLib::Average::Geometric,
payoff, exercise);
option.setPricingEngine(engine);
rl = Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = option.vega(),
Rcpp::Named("theta") = option.theta(),
Rcpp::Named("rho") = option.rho(),
Rcpp::Named("divRho") = option.dividendRho());
} else if (averageType=="arithmetic") {
// TODO: check fixings > 1, first, length
if (first < 0) Rcpp::stop("Parameter 'first' must be non-negative.");
if (length < 0) Rcpp::stop("Parameter 'length' must be non-negative.");
if (fixings <= 1) Rcpp::stop("Parameter 'fixings' must be larger than one.");
boost::shared_ptr<QuantLib::PricingEngine> engine =
QuantLib::MakeMCDiscreteArithmeticAPEngine<QuantLib::LowDiscrepancy>(stochProcess)
.withSamples(2047)
.withControlVariate();
//boost::shared_ptr<PricingEngine> engine =
// MakeMCDiscreteArithmeticASEngine<LowDiscrepancy>(stochProcess)
// .withSeed(3456789)
// .withSamples(1023);
QuantLib::Time dt = length / (fixings - 1);
std::vector<QuantLib::Time> timeIncrements(fixings);
std::vector<QuantLib::Date> fixingDates(fixings);
timeIncrements[0] = first;
fixingDates[0] = today + QuantLib::Integer(timeIncrements[0] * 360 + 0.5);
for (QuantLib::Size i=1; i<fixings; i++) {
timeIncrements[i] = i*dt + first;
#ifdef QL_HIGH_RESOLUTION_DATE
fixingDates[i]= QuantLib::Date(today.dateTime() + boost::posix_time::minutes(boost::uint64_t(timeIncrements[i] * 360 * 24 * 60)));
#else
fixingDates[i] = today + QuantLib::Integer(timeIncrements[i]*360+0.5);
#endif
}
QuantLib::Real runningSum = 0.0;
QuantLib::Size pastFixing = 0;
boost::shared_ptr<QuantLib::Exercise>
exercise(new QuantLib::EuropeanExercise(fixingDates[fixings-1]));
QuantLib::DiscreteAveragingAsianOption option(QuantLib::Average::Arithmetic,
runningSum,
pastFixing,
fixingDates,
payoff,
exercise);
option.setPricingEngine(engine);
rl = Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = R_NaReal,
Rcpp::Named("gamma") = R_NaReal,
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
}
return rl;
}
double MonthlyFixingCurve::getRateSetOn(QuantLib::Date date) const
{
return FixingRateSource::getRateSetOn(Date(1, date.month(), date.year()));
}
bool MonthlyFixingCurve::containsARateSetOn(QuantLib::Date date) const
{
return FixingRateSource::containsARateSetOn(Date(1, date.month(), date.year()));
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
DDS::DomainParticipantFactory_var dpf = DDS::DomainParticipantFactory::_nil();
DDS::DomainParticipant_var participant = DDS::DomainParticipant::_nil();
try
{
QuantLibAddinCpp::initializeAddin();
QuantLib::Calendar calendar = QuantLib::TARGET();
QuantLib::Date settlementDate(22, QuantLib::September, 2004);
settlementDate = calendar.adjust(settlementDate);
QuantLib::Integer fixingDays = 2;
QuantLib::Date todaysDate = calendar.advance(settlementDate, -fixingDays, QuantLib::Days);
QuantLibAddinCpp::qlSettingsSetEvaluationDate( todaysDate.serialNumber(), OH_NULL );
std::cout << "Today: " << todaysDate.weekday() << ", " << todaysDate << std::endl;
std::cout << "Settlement date: " << settlementDate.weekday() << ", " << settlementDate << std::endl;
// Initialize, and create a DomainParticipant
dpf = TheParticipantFactoryWithArgs(argc, argv);
qldds_utils::BasicDomainParticipant irs_participant( dpf, IRS_DOMAIN_ID );
irs_participant.createPublisher();
irs_participant.createSubscriber();
std::string term_structure;
std::vector<std::string> rate_helpers;
ACE_Get_Opt cmd_opts( argc, argv, ":c:n:i:" );
int option;
while ( (option = cmd_opts()) != EOF )
{
switch( option )
{
case 'c' :
{
std::istringstream f( cmd_opts.opt_arg() );
std::string s;
while (std::getline(f, s, '|')) {
rate_helpers.push_back(s);
}
break;
}
case 'n' :
{
term_structure = cmd_opts.opt_arg();
break;
}
}
}
QuantLibAddinCpp::qlLibor("Libor", "USD", "6M", "", false, false, true);
// Topics for Swap Components
// Setting up schedule topic
DDS::Topic_var schedule_topic =
irs_participant.createTopicAndRegisterType
< schedule::qlScheduleTypeSupport_var, schedule::qlScheduleTypeSupportImpl >
( SCHEDULE_TOPIC_NAME );
// setting up vanilla swap topic
DDS::Topic_var vanilla_swap_topic =
irs_participant.createTopicAndRegisterType
< vanillaswap::qlVanillaSwapTypeSupport_var, vanillaswap::qlVanillaSwapTypeSupportImpl >
( VANILLA_SWAP_TOPIC_NAME );
// Topics for curve components
// setting up deposit rate helper
DDS::Topic_var deposit_rate_helper2_topic = irs_participant.createTopicAndRegisterType
< ratehelpers::qlDepositRateHelper2TypeSupport_var, ratehelpers::qlDepositRateHelper2TypeSupportImpl >
( DEPOSIT_RATE_HELPER2_TOPIC_NAME );
// setting up FRA Rate helper
DDS::Topic_var fra_rate_helper2_topic = irs_participant.createTopicAndRegisterType
< ratehelpers::qlFraRateHelper2TypeSupport_var, ratehelpers::qlFraRateHelper2TypeSupportImpl >
( FRA_RATE_HELPER2_TOPIC_NAME );
// setting up Swap Rate helper
DDS::Topic_var swap_rate_helper2_topic = irs_participant.createTopicAndRegisterType
< ratehelpers::qlSwapRateHelper2TypeSupport_var, ratehelpers::qlSwapRateHelper2TypeSupportImpl >
( SWAP_RATE_HELPER2_TOPIC_NAME );
irs_participant.createDataReaderListener< schedule::qlScheduleDataReaderListenerImpl> ( qldds_lock, schedule_topic );
irs_participant.createDataReaderListener< VanillaSwapDataReaderListenerImpl > ( qldds_lock, vanilla_swap_topic );
irs_participant.createDataReaderListener< DepositRateHelper2DataReaderListenerImpl > ( qldds_lock,deposit_rate_helper2_topic );
irs_participant.createDataReaderListener< FraRateHelper2DataReaderListenerImpl > ( qldds_lock, fra_rate_helper2_topic );
irs_participant.createDataReaderListener< SwapRateHelper2DataReaderListenerImpl > ( qldds_lock, swap_rate_helper2_topic );
// setting up IRS Portfolio. Priced portfolios will be published on this topic
DDS::Topic_var irs_portfolio_topic = irs_participant.createTopicAndRegisterType
< IRS::PortfolioTypeSupport_var, IRS::PortfolioTypeSupportImpl >
( IRS_PORTFOLIO_TOPIC_NAME );
IRS::PortfolioDataWriter_var irs_portfolio_dw = irs_participant.createDataWriter
< IRS::PortfolioDataWriter_var, IRS::PortfolioDataWriter >
( irs_portfolio_topic );
curves.insert( std::pair < std::string, std::vector< std::string > > ( term_structure, rate_helpers ) );
int calculation_performed = 0;
while ( calculation_performed < 30 )
{
IRS::Portfolio irs_portfolio_out;
if ( computeNPVs( term_structure, irs_portfolio_out ) == false )
{
ACE_Time_Value sleep_100ms( 0, 100000 );
ACE_OS::sleep( sleep_100ms );
continue;
} else {
calculation_performed++;
ACE_OS::sleep(1);
}
std::cout << "Calculator ["<< term_structure << "] publishing NPVs for "<< irs_portfolio_out.swaps.length() << " interest rate swaps."<< std::endl;
int ret = irs_portfolio_dw->write( irs_portfolio_out, DDS::HANDLE_NIL );
if (ret != DDS::RETCODE_OK) {
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: IRS Portfolio write returned %d.\n"), ret));
}
}
} catch (CORBA::Exception& e)
{
cerr << "Exception caught in main.cpp:" << endl << e << endl;
ACE_OS::exit(1);
}
TheServiceParticipant->shutdown();
return 0;
}
// [[Rcpp::export]]
Rcpp::List europeanOptionEngine(std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividends,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividendsTimeUntil) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Option::Type optionType = getOptionType(type);
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
// new framework as per QuantLib 0.3.5
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote( underlying ));
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote( volatility ));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote( dividendYield ));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote( riskFreeRate ));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
bool withDividends = discreteDividends.isNotNull() && discreteDividendsTimeUntil.isNotNull();
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
if (withDividends) {
Rcpp::NumericVector divvalues(discreteDividends), divtimes(discreteDividendsTimeUntil);
int n = divvalues.size();
std::vector<QuantLib::Date> discDivDates(n);
std::vector<double> discDividends(n);
for (int i = 0; i < n; i++) {
#ifdef QL_HIGH_RESOLUTION_DATE
boost::posix_time::time_duration discreteDividendLength = boost::posix_time::minutes(boost::uint64_t(divtimes[i] * 360 * 24 * 60));
discDivDates[i] = QuantLib::Date(today.dateTime() + discreteDividendLength);
#else
discDivDates[i] = today + int(divtimes[i] * 360 + 0.5);
#endif
discDividends[i] = divvalues[i];
}
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::AnalyticDividendEuropeanEngine(stochProcess));
QuantLib::DividendVanillaOption option(payoff, exercise, discDivDates, discDividends);
option.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = option.vega(),
Rcpp::Named("theta") = option.theta(),
Rcpp::Named("rho") = option.rho(),
Rcpp::Named("divRho") = R_NaReal);
}
else {
boost::shared_ptr<QuantLib::VanillaOption> option = makeOption(payoff, exercise, spot, qTS, rTS, volTS);
return Rcpp::List::create(Rcpp::Named("value") = option->NPV(),
Rcpp::Named("delta") = option->delta(),
Rcpp::Named("gamma") = option->gamma(),
Rcpp::Named("vega") = option->vega(),
Rcpp::Named("theta") = option->theta(),
Rcpp::Named("rho") = option->rho(),
Rcpp::Named("divRho") = option->dividendRho());
}
}
// [[Rcpp::export]]
Rcpp::List americanOptionEngine(std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
int timeSteps,
int gridPoints,
std::string engine,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividends,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividendsTimeUntil) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity * 360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Option::Type optionType = getOptionType(type);
// new framework as per QuantLib 0.3.5, updated for 0.3.7
// updated again for 0.9.0, see eg test-suite/americanoption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today,qRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today,rRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
bool withDividends = discreteDividends.isNotNull() && discreteDividendsTimeUntil.isNotNull();
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::AmericanExercise(today, exDate));
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
if (withDividends) {
Rcpp::NumericVector divvalues(discreteDividends), divtimes(discreteDividendsTimeUntil);
int n = divvalues.size();
std::vector<QuantLib::Date> discDivDates(n);
std::vector<double> discDividends(n);
for (int i = 0; i < n; i++) {
#ifdef QL_HIGH_RESOLUTION_DATE
boost::posix_time::time_duration discreteDividendLength = boost::posix_time::minutes(boost::uint64_t(divtimes[i] * 360 * 24 * 60));
discDivDates[i] = QuantLib::Date(today.dateTime() + discreteDividendLength);
#else
discDivDates[i] = today + int(divtimes[i] * 360 + 0.5);
#endif
discDividends[i] = divvalues[i];
}
QuantLib::DividendVanillaOption option(payoff, exercise, discDivDates, discDividends);
if (engine=="BaroneAdesiWhaley") {
Rcpp::warning("Discrete dividends, engine switched to CrankNicolson");
engine = "CrankNicolson";
}
if (engine=="CrankNicolson") { // FDDividendAmericanEngine only works with CrankNicolson
// suggestion by Bryan Lewis: use CrankNicolson for greeks
boost::shared_ptr<QuantLib::PricingEngine>
fdcnengine(new QuantLib::FDDividendAmericanEngine<QuantLib::CrankNicolson>(stochProcess, timeSteps, gridPoints));
option.setPricingEngine(fdcnengine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
} else {
throw std::range_error("Unknown engine " + engine);
}
} else {
QuantLib::VanillaOption option(payoff, exercise);
if (engine=="BaroneAdesiWhaley") {
// new from 0.3.7 BaroneAdesiWhaley
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::BaroneAdesiWhaleyApproximationEngine(stochProcess));
option.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = R_NaReal,
Rcpp::Named("gamma") = R_NaReal,
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
} else if (engine=="CrankNicolson") {
// suggestion by Bryan Lewis: use CrankNicolson for greeks
boost::shared_ptr<QuantLib::PricingEngine>
fdcnengine(new QuantLib::FDAmericanEngine<QuantLib::CrankNicolson>(stochProcess, timeSteps, gridPoints));
option.setPricingEngine(fdcnengine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
} else {
throw std::range_error("Unknown engine " + engine);
}
}
}
std::string BondTableModel::dateToString(QuantLib::Date d) const {
std::stringstream stream;
stream << d.dayOfMonth() << "-" << d.month() << "-" << d.year();
return stream.str();
}
