CmdOptions parseOptions(int argc, char* argv[])
{
CmdOptions opts;
vector<maxint_t> numbers;
for (int i = 1; i < argc; i++)
{
Option opt = makeOption(argv[i]);
switch (optionMap[opt.opt])
{
case OPTION_ALPHA: set_alpha(stod(opt.val)); break;
case OPTION_NUMBER: numbers.push_back(opt.to<maxint_t>()); break;
case OPTION_THREADS: set_num_threads(opt.to<int>()); break;
case OPTION_PHI: opts.a = opt.to<int64_t>(); opts.option = OPTION_PHI; break;
case OPTION_HELP: help(); break;
case OPTION_STATUS: optionStatus(opt, opts); break;
case OPTION_TIME: opts.time = true; break;
case OPTION_TEST: test(); break;
case OPTION_VERSION: version(); break;
default: opts.option = optionMap[opt.opt];
}
}
if (numbers.empty())
throw primecount_error("missing x number");
else
opts.x = numbers[0];
return opts;
}
// [[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);
}
// [[Rcpp::export]]
double europeanOptionImpliedVolatilityEngine(std::string type,
double value,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility) {
const QuantLib::Size maxEvaluations = 100;
const double tolerance = 1.0e-6;
int length = int(maturity*360 + 0.5); // FIXME: this could be better
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
// updated for 0.3.7
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);
QuantLib::Date exDate = today + length;
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, Analytic,
QuantLib::Null<QuantLib::Size>(),
QuantLib::Null<QuantLib::Size>());
boost::shared_ptr<QuantLib::GeneralizedBlackScholesProcess>
process = makeProcess(spot, qTS, rTS,volTS);
double volguess = volatility;
vol->setValue(volguess);
return option->impliedVolatility(value, process, tolerance, maxEvaluations);
}
Config::Config(const QCoreApplication & app)
: m_screen(-1)
, m_x(0)
, m_y(0)
, m_width(800)
, m_height(600)
, m_fullscreen(false)
, m_window_type_hint(NetWmWindowType::Normal)
{
QCommandLineParser parser;
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption screenOption = makeOption(QStringList() << "s" << "screen", "The screen where quadro should appear", "screen");
QCommandLineOption xOption = makeOption(QStringList() << "x", "x position on screen", "x");
QCommandLineOption yOption = makeOption(QStringList() << "y", "y position on screen", "y");
QCommandLineOption widthOption = makeOption(QStringList() << "width", "window width", "width");
QCommandLineOption heightOption = makeOption(QStringList() << "height", "window height", "height");
QCommandLineOption urlOption = makeOption(QStringList() << "u" << "url", "URL to load at startup", "url");
QCommandLineOption fullscreenOption(QStringList() << "f" << "fullscreen", "Set window to fullscreen mode");
QCommandLineOption maxVertOption(QStringList() << "maximize-vertical", "Maximize window vertically");
QCommandLineOption maxHorzOption(QStringList() << "maximize-horizontal", "Maximize window horizontally");
QCommandLineOption windowTypeOption = makeOption(QStringList() << "t" << "type", "Set window type: normal, desktop, dock (default: normal)", "type");
parser.addOption(screenOption);
parser.addOption(xOption);
parser.addOption(yOption);
parser.addOption(widthOption);
parser.addOption(heightOption);
parser.addOption(urlOption);
parser.addOption(fullscreenOption);
parser.addOption(maxVertOption);
parser.addOption(maxHorzOption);
parser.addOption(windowTypeOption);
parser.process(app);
if (parser.isSet(screenOption)) {
m_screen = parser.value(screenOption);
}
if (parser.isSet(xOption)) {
m_x = X(std::stod(parser.value(xOption).toStdString()));
}
if (parser.isSet(yOption)) {
m_y = Y(std::stod(parser.value(yOption).toStdString()));
}
if (parser.isSet(widthOption)) {
m_width = std::stoul(parser.value(widthOption).toStdString());
}
if (parser.isSet(heightOption)) {
m_height = std::stoul(parser.value(heightOption).toStdString());
}
m_url = parser.value(urlOption);
m_fullscreen = parser.isSet(fullscreenOption);
m_max_vertical = parser.isSet(maxVertOption);
m_max_horizontal = parser.isSet(maxHorzOption);
auto type = parser.value(windowTypeOption);
if (type == "normal") {
m_window_type_hint = NetWmWindowType::Normal;
} else if (type == "desktop") {
m_window_type_hint = NetWmWindowType::Desktop;
} else if (type == "dock") {
m_window_type_hint = NetWmWindowType::Dock;
}
}
// [[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());
}
}
