public void testFdmHestonAmerican()
{
//Testing FDM with American option in Heston model...
using (SavedSettings backup = new SavedSettings())
{
Handle <Quote> s0 = new Handle <Quote>(new SimpleQuote(100.0));
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(Utilities.flatRate(0.05, new Actual365Fixed()));
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(Utilities.flatRate(0.0, new Actual365Fixed()));
HestonProcess hestonProcess = new HestonProcess(rTS, qTS, s0, 0.04, 2.5, 0.04, 0.66, -0.8);
Settings.Instance.setEvaluationDate(new Date(28, 3, 2004));
Date exerciseDate = new Date(28, 3, 2005);
Exercise exercise = new AmericanExercise(exerciseDate);
StrikedTypePayoff payoff = new PlainVanillaPayoff(Option.Type.Put, 100);
VanillaOption option = new VanillaOption(payoff, exercise);
IPricingEngine engine = new FdHestonVanillaEngine(new HestonModel(hestonProcess), 200, 100, 50);
option.setPricingEngine(engine);
double tol = 0.01;
double npvExpected = 5.66032;
double deltaExpected = -0.30065;
double gammaExpected = 0.02202;
if (Math.Abs(option.NPV() - npvExpected) > tol)
{
QAssert.Fail("Failed to reproduce expected npv"
+ "\n calculated: " + option.NPV()
+ "\n expected: " + npvExpected
+ "\n tolerance: " + tol);
}
if (Math.Abs(option.delta() - deltaExpected) > tol)
{
QAssert.Fail("Failed to reproduce expected delta"
+ "\n calculated: " + option.delta()
+ "\n expected: " + deltaExpected
+ "\n tolerance: " + tol);
}
if (Math.Abs(option.gamma() - gammaExpected) > tol)
{
QAssert.Fail("Failed to reproduce expected gamma"
+ "\n calculated: " + option.gamma()
+ "\n expected: " + gammaExpected
+ "\n tolerance: " + tol);
}
}
}
public void calculate(double[] p, GBMParaViewModel para)
{
this.xData_ = p;
this.yData_ = new double[p.Length];
double sellBuySign = 1.0;
if (this.sellBuy_ == "매도")
{
sellBuySign = -1.0;
}
else
{
}
// set up dates
Calendar calendar = new TARGET();
//Date todaysDate = new Date(DateTime.Now);
Date settlementDate = new Date(para.ReferenceDate_);
Settings.setEvaluationDate(settlementDate);
// our options
Option.Type type = this.callPutEnum_;
double underlying = para.CurrentPrice_;
double strike = this.strike_;
double dividendYield = para.Dividend_ / 100;
double riskFreeRate = para.Drift_ / 100;
if (this.callPutEnum_ == Option.Type.Call)
{
this.imVol_ = para.Call_Interpolation_.value(this.strike_);
}
else if (this.callPutEnum_ == Option.Type.Put)
{
this.imVol_ = para.Put_Interpolation_.value(this.strike_);
}
double volatility = (this.imVol_) / 100;
Date maturity = new Date(this.maturiry_.AddDays(1));
if (this.callPutEnum_ == 0)
{
this.deltaCal_ = 1.0;
this.gammaCal_ = 0.0;
this.vegaCal_ = 0.0;
this.thetaCal_ = 0.0;
this.rhoCal_ = 0.0;
this.deltaPosition_ = sellBuySign * this.unit_ * 500000 * underlying;
this.deltaRisk_ = this.deltaPosition_ * 0.09;
this.gammaRisk_ = 0.0;
this.vegaRisk_ = 0.0;
this.totalRisk_ = this.deltaRisk_ + this.gammaRisk_ + this.vegaRisk_;
this.deepOTM_ = 0.0;
//this.remainDays_ = maturity - settlementDate;
this.remainDays_ = (this.maturiry_ - para.ReferenceDate_).Days + 1;
return;
}
DayCounter dayCounter = new Actual365Fixed();
Exercise europeanExercise = new EuropeanExercise(maturity);
SimpleQuote quote = new SimpleQuote(underlying);
Handle <Quote> underlyingH = new Handle <Quote>(quote);
// bootstrap the yield/dividend/vol curves
var flatTermStructure = new Handle <YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
var flatDividendTS = new Handle <YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
var flatVolTS = new Handle <BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility, dayCounter));
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
var bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
// options
VanillaOption europeanOption = new VanillaOption(payoff, europeanExercise);
// Analytic formulas:
// Black-Scholes for European
europeanOption.setPricingEngine(new AnalyticEuropeanEngine(bsmProcess));
this.npv_ = Math.Round(europeanOption.NPV(), 6);
this.deltaCal_ = sellBuySign * Math.Round(europeanOption.delta(), 6);
this.gammaCal_ = sellBuySign * Math.Round(europeanOption.gamma(), 6);
this.vegaCal_ = sellBuySign * Math.Round(europeanOption.vega() / 100, 6);
this.thetaCal_ = sellBuySign * Math.Round(europeanOption.theta() / 365, 6);
this.rhoCal_ = sellBuySign * Math.Round(europeanOption.rho() / 100, 6);
this.deltaPosition_ = Math.Round(this.deltaCal_ * this.unit_ * 500000 * underlying, 0);
this.deltaRisk_ = Math.Round(this.deltaPosition_ * 0.09, 0);
this.gammaRisk_ = Math.Round(0.5 * this.gammaCal_ * (underlying * underlying * 0.08 * 0.08) * this.unit_ * 500000, 0);
this.vegaRisk_ = Math.Round(this.vegaCal_ * this.imVol_ * 0.25 * this.unit_ * 500000, 0);
this.totalRisk_ = this.deltaRisk_ + this.gammaRisk_ + this.vegaRisk_;
this.deepOTM_ = 0.0;
//this.remainDays_ = maturity - settlementDate;
this.remainDays_ = (this.maturiry_ - para.ReferenceDate_).Days + 1;
for (int i = 0; i < this.xData_.Length; i++)
{
quote.setValue(this.xData_[i]);
this.yData_[i] = 500000.0 * (double)this.unit_ * europeanOption.NPV();
}
}
public void testCrankNicolsonWithDamping()
{
SavedSettings backup = new SavedSettings();
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(100.0);
YieldTermStructure qTS = Utilities.flatRate(today, 0.06, dc);
YieldTermStructure rTS = Utilities.flatRate(today, 0.06, dc);
BlackVolTermStructure volTS = Utilities.flatVol(today, 0.35, dc);
StrikedTypePayoff payoff =
new CashOrNothingPayoff(Option.Type.Put, 100, 10.0);
double maturity = 0.75;
Date exDate = today + Convert.ToInt32(maturity * 360 + 0.5);
Exercise exercise = new EuropeanExercise(exDate);
BlackScholesMertonProcess process = new
BlackScholesMertonProcess(new Handle <Quote>(spot),
new Handle <YieldTermStructure>(qTS),
new Handle <YieldTermStructure>(rTS),
new Handle <BlackVolTermStructure>(volTS));
IPricingEngine engine =
new AnalyticEuropeanEngine(process);
VanillaOption opt = new VanillaOption(payoff, exercise);
opt.setPricingEngine(engine);
double expectedPV = opt.NPV();
double expectedGamma = opt.gamma();
// fd pricing using implicit damping steps and Crank Nicolson
int csSteps = 25, dampingSteps = 3, xGrid = 400;
List <int> dim = new InitializedList <int>(1, xGrid);
FdmLinearOpLayout layout = new FdmLinearOpLayout(dim);
Fdm1dMesher equityMesher =
new FdmBlackScholesMesher(
dim[0], process, maturity, payoff.strike(),
null, null, 0.0001, 1.5,
new Pair <double?, double?>(payoff.strike(), 0.01));
FdmMesher mesher =
new FdmMesherComposite(equityMesher);
FdmBlackScholesOp map =
new FdmBlackScholesOp(mesher, process, payoff.strike());
FdmInnerValueCalculator calculator =
new FdmLogInnerValue(payoff, mesher, 0);
object rhs = new Vector(layout.size());
Vector x = new Vector(layout.size());
FdmLinearOpIterator endIter = layout.end();
for (FdmLinearOpIterator iter = layout.begin(); iter != endIter;
++iter)
{
(rhs as Vector)[iter.index()] = calculator.avgInnerValue(iter, maturity);
x[iter.index()] = mesher.location(iter, 0);
}
FdmBackwardSolver solver = new FdmBackwardSolver(map, new FdmBoundaryConditionSet(),
new FdmStepConditionComposite(),
new FdmSchemeDesc().Douglas());
solver.rollback(ref rhs, maturity, 0.0, csSteps, dampingSteps);
MonotonicCubicNaturalSpline spline = new MonotonicCubicNaturalSpline(x, x.Count, rhs as Vector);
double s = spot.value();
double calculatedPV = spline.value(Math.Log(s));
double calculatedGamma = (spline.secondDerivative(Math.Log(s))
- spline.derivative(Math.Log(s))) / (s * s);
double relTol = 2e-3;
if (Math.Abs(calculatedPV - expectedPV) > relTol * expectedPV)
{
QAssert.Fail("Error calculating the PV of the digital option" +
"\n rel. tolerance: " + relTol +
"\n expected: " + expectedPV +
"\n calculated: " + calculatedPV);
}
if (Math.Abs(calculatedGamma - expectedGamma) > relTol * expectedGamma)
{
QAssert.Fail("Error calculating the Gamma of the digital option" +
"\n rel. tolerance: " + relTol +
"\n expected: " + expectedGamma +
"\n calculated: " + calculatedGamma);
}
}
public void testCashAtHitOrNothingAmericanGreeks()
{
// Testing American cash-(at-hit)-or-nothing digital option greeks
SavedSettings backup = new SavedSettings();
SortedDictionary <string, double> calculated = new SortedDictionary <string, double>();
SortedDictionary <string, double> expected = new SortedDictionary <string, double>();
SortedDictionary <string, double> tolerance = new SortedDictionary <string, double>(); // std::map<std::string,Real> calculated, expected, tolerance;
tolerance["delta"] = 5.0e-5;
tolerance["gamma"] = 5.0e-5;
tolerance["rho"] = 5.0e-5;
Option.Type[] types = { QLNet.Option.Type.Call, QLNet.Option.Type.Put };
double[] strikes = { 50.0, 99.5, 100.5, 150.0 };
double cashPayoff = 100.0;
double[] underlyings = { 100 };
double[] qRates = { 0.04, 0.05, 0.06 };
double[] rRates = { 0.01, 0.05, 0.15 };
double[] vols = { 0.11, 0.5, 1.2 };
DayCounter dc = new Actual360();
Date today = Date.Today;
Settings.setEvaluationDate(today);
SimpleQuote spot = new SimpleQuote(0.0);
SimpleQuote qRate = new SimpleQuote(0.0);
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(Utilities.flatRate(qRate, dc));
SimpleQuote rRate = new SimpleQuote(0.0);
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(Utilities.flatRate(rRate, dc));
SimpleQuote vol = new SimpleQuote(0.0);
Handle <BlackVolTermStructure> volTS = new Handle <BlackVolTermStructure>(Utilities.flatVol(vol, dc));
// there is no cycling on different residual times
Date exDate = today + 360;
Exercise exercise = new EuropeanExercise(exDate);
Exercise amExercise = new AmericanExercise(today, exDate, false);
Exercise[] exercises = { exercise, amExercise };
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(new Handle <Quote>(spot), qTS, rTS, volTS);
IPricingEngine euroEngine = new AnalyticEuropeanEngine(stochProcess);
IPricingEngine amEngine = new AnalyticDigitalAmericanEngine(stochProcess);
IPricingEngine[] engines = { euroEngine, amEngine };
bool knockin = true;
for (int j = 0; j < engines.Length; j++)
{
for (int i1 = 0; i1 < types.Length; i1++)
{
for (int i6 = 0; i6 < strikes.Length; i6++)
{
StrikedTypePayoff payoff = new CashOrNothingPayoff(types[i1], strikes[i6], cashPayoff);
VanillaOption opt = new VanillaOption(payoff, exercises[j]);
opt.setPricingEngine(engines[j]);
for (int i2 = 0; i2 < underlyings.Length; i2++)
{
for (int i4 = 0; i4 < qRates.Length; i4++)
{
for (int i3 = 0; i3 < rRates.Length; i3++)
{
for (int i7 = 0; i7 < vols.Length; i7++)
{
// test data
double u = underlyings[i2];
double q = qRates[i4];
double r = rRates[i3];
double v = vols[i7];
spot.setValue(u);
qRate.setValue(q);
rRate.setValue(r);
vol.setValue(v);
// theta, dividend rho and vega are not available for
// digital option with american exercise. Greeks of
// digital options with european payoff are tested
// in the europeanoption.cpp test
double value = opt.NPV();
calculated["delta"] = opt.delta();
calculated["gamma"] = opt.gamma();
calculated["rho"] = opt.rho();
if (value > 1.0e-6)
{
// perturb spot and get delta and gamma
double du = u * 1.0e-4;
spot.setValue(u + du);
double value_p = opt.NPV(),
delta_p = opt.delta();
spot.setValue(u - du);
double value_m = opt.NPV(),
delta_m = opt.delta();
spot.setValue(u);
expected["delta"] = (value_p - value_m) / (2 * du);
expected["gamma"] = (delta_p - delta_m) / (2 * du);
// perturb rates and get rho and dividend rho
double dr = r * 1.0e-4;
rRate.setValue(r + dr);
value_p = opt.NPV();
rRate.setValue(r - dr);
value_m = opt.NPV();
rRate.setValue(r);
expected["rho"] = (value_p - value_m) / (2 * dr);
// check
//std::map<std::string,Real>::iterator it;
foreach (var it in calculated)
{
string greek = it.Key;
double expct = expected [greek],
calcl = calculated[greek],
tol = tolerance [greek];
double error = Utilities.relativeError(expct, calcl, value);
if (error > tol)
{
REPORT_FAILURE(greek, payoff, exercise,
u, q, r, today, v,
expct, calcl, error, tol, knockin);
}
}
}
}
}
}
}
}
}
}
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
Option.Type optionType;
if (CallorPut.Text == "Call")
{
optionType = Option.Type.Call;
}
else
{
optionType = Option.Type.Put;
}
double underlyingPrice = Convert.ToDouble(Stockprice.Text);
double strikePrice = Convert.ToDouble(Strikeprice.Text);
double dividendYield = 0.0;
double riskFreeRate = Convert.ToDouble(Intrate.Text);
double volatility = Convert.ToDouble(Resultvol.Text) / 100;
Date todaydate = Date.todaysDate();
string expd = Datepick.Text;
Date maturityDate = new Date();
if (expd[1].ToString() is "/")
{
expd = '0' + expd;
}
if (expd[4].ToString() is "/")
{
expd = expd.Substring(0, 3) + '0' + expd.Substring(3);
}
maturityDate = DateParser.parseFormatted(expd, "%m/%d/%Y");
Settings.instance().setEvaluationDate(todaydate);
Date settlementDate = new Date();
settlementDate = todaydate;
QuantLib.Calendar calendar = new TARGET();
AmericanExercise americanExercise =
new AmericanExercise(settlementDate, maturityDate);
EuropeanExercise europeanExercise =
new EuropeanExercise(maturityDate);
DayCounter dayCounter = new Actual365Fixed();
YieldTermStructureHandle flatRateTSH =
new YieldTermStructureHandle(
new FlatForward(settlementDate, riskFreeRate,
dayCounter));
YieldTermStructureHandle flatDividendTSH =
new YieldTermStructureHandle(
new FlatForward(settlementDate, dividendYield,
dayCounter));
BlackVolTermStructureHandle flatVolTSH =
new BlackVolTermStructureHandle(
new BlackConstantVol(settlementDate, calendar,
volatility, dayCounter));
QuoteHandle underlyingQuoteH =
new QuoteHandle(new SimpleQuote(underlyingPrice));
BlackScholesMertonProcess stochasticProcess =
new BlackScholesMertonProcess(underlyingQuoteH,
flatDividendTSH,
flatRateTSH,
flatVolTSH);
PlainVanillaPayoff payoff =
new PlainVanillaPayoff(optionType, strikePrice);
VanillaOption americanOption =
new VanillaOption(payoff, americanExercise);
VanillaOption americanOption2 =
new VanillaOption(payoff, americanExercise);
VanillaOption europeanOption =
new VanillaOption(payoff, europeanExercise);
americanOption.setPricingEngine(
new BaroneAdesiWhaleyEngine(stochasticProcess));
americanOption2.setPricingEngine(
new BinomialVanillaEngine(stochasticProcess, "coxrossrubinstein", 1000));
europeanOption.setPricingEngine(
new AnalyticEuropeanEngine(stochasticProcess));
//double opprice = Math.Round(americanOption2.NPV(), 3);
Date divdate1 = new Date(14, Month.January, 2019);
DoubleVector divpay = new DoubleVector();
DateVector divDates = new DateVector();
//divpay.Add(.0001);
//divDates.Add(divdate1);
DividendVanillaOption americanOption1 = new DividendVanillaOption(payoff, americanExercise, divDates, divpay);
FDDividendAmericanEngine engine = new FDDividendAmericanEngine(stochasticProcess);
americanOption1.setPricingEngine(engine);
//double opprice4 = americanOption1.NPV();
double Inoprice = Convert.ToDouble(Resultam.Text);
double vol1 = americanOption1.impliedVolatility(Inoprice, stochasticProcess, .0001);
vol1 = Math.Round(vol1, 4) * 100;
double delta1 = Math.Round(americanOption2.delta(), 2);
double gamma1 = Math.Round(americanOption2.gamma(), 2);
double theta1 = Math.Round(europeanOption.theta() / 365, 2);
double vega1 = Math.Round(europeanOption.vega() / 100, 2);
//Resultam.Text = opprice4.ToString();
Resultam_Delta.Text = delta1.ToString();
Resultam_Gamma.Text = gamma1.ToString();
Resultam_Theta.Text = theta1.ToString();
Resultam_Vega.Text = vega1.ToString();
Resultvol.Text = vol1.ToString();
}
public void testFdGreeks <Engine>() where Engine : IFDEngine, new()
{
using (SavedSettings backup = new SavedSettings())
{
Dictionary <string, double> calculated = new Dictionary <string, double>(),
expected = new Dictionary <string, double>(),
tolerance = new Dictionary <string, double>();
tolerance.Add("delta", 7.0e-4);
tolerance.Add("gamma", 2.0e-4);
//tolerance["theta"] = 1.0e-4;
Option.Type[] types = new Option.Type[] { Option.Type.Call, Option.Type.Put };
double[] strikes = { 50.0, 99.5, 100.0, 100.5, 150.0 };
double[] underlyings = { 100.0 };
double[] qRates = { 0.04, 0.05, 0.06 };
double[] rRates = { 0.01, 0.05, 0.15 };
int[] years = { 1, 2 };
double[] vols = { 0.11, 0.50, 1.20 };
Date today = Date.Today;
Settings.setEvaluationDate(today);
DayCounter dc = new Actual360();
SimpleQuote spot = new SimpleQuote(0.0);
SimpleQuote qRate = new SimpleQuote(0.0);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.0);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.0);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
for (int i = 0; i < types.Length; i++)
{
for (int j = 0; j < strikes.Length; j++)
{
for (int k = 0; k < years.Length; k++)
{
Date exDate = today + new Period(years[k], TimeUnit.Years);
Exercise exercise = new AmericanExercise(today, exDate);
StrikedTypePayoff payoff = new PlainVanillaPayoff(types[i], strikes[j]);
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(new Handle <Quote>(spot),
new Handle <YieldTermStructure>(qTS),
new Handle <YieldTermStructure>(rTS),
new Handle <BlackVolTermStructure>(volTS));
IPricingEngine engine = new Engine().factory(stochProcess);
VanillaOption option = new VanillaOption(payoff, exercise);
option.setPricingEngine(engine);
for (int l = 0; l < underlyings.Length; l++)
{
for (int m = 0; m < qRates.Length; m++)
{
for (int n = 0; n < rRates.Length; n++)
{
for (int p = 0; p < vols.Length; p++)
{
double u = underlyings[l];
double q = qRates[m],
r = rRates[n];
double v = vols[p];
spot.setValue(u);
qRate.setValue(q);
rRate.setValue(r);
vol.setValue(v);
double value = option.NPV();
calculated.Add("delta", option.delta());
calculated.Add("gamma", option.gamma());
//calculated["theta"] = option.theta();
if (value > spot.value() * 1.0e-5)
{
// perturb spot and get delta and gamma
double du = u * 1.0e-4;
spot.setValue(u + du);
double value_p = option.NPV(),
delta_p = option.delta();
spot.setValue(u - du);
double value_m = option.NPV(),
delta_m = option.delta();
spot.setValue(u);
expected.Add("delta", (value_p - value_m) / (2 * du));
expected.Add("gamma", (delta_p - delta_m) / (2 * du));
/*
* // perturb date and get theta
* Time dT = dc.yearFraction(today-1, today+1);
* Settings::instance().setEvaluationDate(today-1);
* value_m = option.NPV();
* Settings::instance().setEvaluationDate(today+1);
* value_p = option.NPV();
* Settings::instance().setEvaluationDate(today);
* expected["theta"] = (value_p - value_m)/dT;
*/
// compare
foreach (string greek in calculated.Keys)
{
double expct = expected[greek],
calcl = calculated[greek],
tol = tolerance[greek];
double error = Utilities.relativeError(expct, calcl, u);
if (error > tol)
{
REPORT_FAILURE(greek, payoff, exercise,
u, q, r, today, v,
expct, calcl, error, tol);
}
}
}
calculated.Clear();
expected.Clear();
}
}
}
}
}
}
}
}
}
//void testEngineConsistency(EngineType engine, int binomialSteps, int samples, Dictionary<string,double> tolerance,
// bool testGreeks = false) {
void testEngineConsistency(EngineType engine, int binomialSteps, int samples, Dictionary <string, double> tolerance,
bool testGreeks)
{
//QL_TEST_START_TIMING
Dictionary <string, double> calculated = new Dictionary <string, double>(), expected = new Dictionary <string, double>();
// test options
Option.Type[] types = { Option.Type.Call, Option.Type.Put };
double[] strikes = { 75.0, 100.0, 125.0 };
int[] lengths = { 1 };
// test data
double[] underlyings = { 100.0 };
double[] qRates = { 0.00, 0.05 };
double[] rRates = { 0.01, 0.05, 0.15 };
double[] vols = { 0.11, 0.50, 1.20 };
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(0.0);
SimpleQuote vol = new SimpleQuote(0.0);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
SimpleQuote qRate = new SimpleQuote(0.0);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.0);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
for (int i = 0; i < types.Length; i++)
{
for (int j = 0; j < strikes.Length; j++)
{
for (int k = 0; k < lengths.Length; k++)
{
Date exDate = today + lengths[k] * 360;
Exercise exercise = new EuropeanExercise(exDate);
StrikedTypePayoff payoff = new PlainVanillaPayoff(types[i], strikes[j]);
// reference option
VanillaOption refOption = makeOption(payoff, exercise, spot, qTS, rTS, volTS,
EngineType.Analytic, 0, 0);
// option to check
VanillaOption option = makeOption(payoff, exercise, spot, qTS, rTS, volTS,
engine, binomialSteps, samples);
for (int l = 0; l < underlyings.Length; l++)
{
for (int m = 0; m < qRates.Length; m++)
{
for (int n = 0; n < rRates.Length; n++)
{
for (int p = 0; p < vols.Length; p++)
{
double u = underlyings[l];
double q = qRates[m],
r = rRates[n];
double v = vols[p];
spot.setValue(u);
qRate.setValue(q);
rRate.setValue(r);
vol.setValue(v);
expected.Clear();
calculated.Clear();
// FLOATING_POINT_EXCEPTION
expected.Add("value", refOption.NPV());
calculated.Add("value", option.NPV());
if (testGreeks && option.NPV() > spot.value() * 1.0e-5)
{
expected.Add("delta", refOption.delta());
expected.Add("gamma", refOption.gamma());
expected.Add("theta", refOption.theta());
calculated.Add("delta", option.delta());
calculated.Add("gamma", option.gamma());
calculated.Add("theta", option.theta());
}
foreach (string greek in calculated.Keys)
{
double expct = expected[greek],
calcl = calculated[greek],
tol = tolerance[greek];
double error = Utilities.relativeError(expct, calcl, u);
if (error > tol)
{
REPORT_FAILURE(greek, payoff, exercise,
u, q, r, today, v,
expct, calcl, error, tol);
}
}
}
}
}
}
}
}
}
}
public void calculate(GBMParaViewModel para)
{
// set up dates
Calendar calendar = new TARGET();
//Date todaysDate = new Date(DateTime.Now);
Date settlementDate = new Date(para.ReferenceDate_);
Settings.setEvaluationDate(settlementDate);
// our options
Option.Type type = this.callPutEnum_;
double underlying = para.CurrentPrice_;
double strike = this.strike_;
double dividendYield = para.Dividend_ / 100;
double riskFreeRate = para.Drift_ / 100;
double volatility = 0.0;
if (this.callPutEnum_ == Option.Type.Call)
{
try
{
volatility = para.Call_Interpolation_.value(this.strike_) / 100;
this.imVolCal_ = Math.Round(para.Call_Interpolation_.value(this.strike_), 1);
}
catch (Exception)
{
volatility = para.Call_Interpolation_.value(this.strike_, true) / 100;
this.imVolCal_ = Math.Round(para.Call_Interpolation_.value(this.strike_, true), 1);
}
}
else if (this.callPutEnum_ == Option.Type.Put)
{
try
{
volatility = para.Call_Interpolation_.value(this.strike_) / 100;
this.imVolCal_ = Math.Round(para.Put_Interpolation_.value(this.strike_), 1);
}
catch (Exception)
{
volatility = para.Call_Interpolation_.value(this.strike_, true) / 100;
this.imVolCal_ = Math.Round(para.Put_Interpolation_.value(this.strike_, true), 1);
}
}
Date maturity = new Date(this.maturiry_);
DayCounter dayCounter = new Actual365Fixed();
//// write column headings
//int[] widths = new int[] { 35, 14, 14, 14 };
//Console.Write("{0,-" + widths[0] + "}", "Method");
//Console.Write("{0,-" + widths[1] + "}", "European");
//Console.Write("{0,-" + widths[2] + "}", "Bermudan");
//Console.WriteLine("{0,-" + widths[3] + "}", "American");
//List<Date> exerciseDates = new List<Date>(); ;
//for (int i = 1; i <= 4; i++)
// exerciseDates.Add(settlementDate + new Period(3 * i, TimeUnit.Months));
Exercise europeanExercise = new EuropeanExercise(maturity);
//Exercise bermudanExercise = new BermudanExercise(exerciseDates);
//Exercise americanExercise = new AmericanExercise(settlementDate, maturity);
Handle <Quote> underlyingH = new Handle <Quote>(new SimpleQuote(underlying));
// bootstrap the yield/dividend/vol curves
var flatTermStructure = new Handle <YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
var flatDividendTS = new Handle <YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
var flatVolTS = new Handle <BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility, dayCounter));
StrikedTypePayoff payoff = new PlainVanillaPayoff(type, strike);
var bsmProcess = new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
// options
VanillaOption europeanOption = new VanillaOption(payoff, europeanExercise);
// Analytic formulas:
// Black-Scholes for European
europeanOption.setPricingEngine(new AnalyticEuropeanEngine(bsmProcess));
this.npv_ = Math.Round(europeanOption.NPV(), 6);
this.deltaCal_ = Math.Round(europeanOption.delta(), 6);
this.gammaCal_ = Math.Round(europeanOption.gamma(), 6);
this.vegaCal_ = Math.Round(europeanOption.vega() / 100, 6);
this.thetaCal_ = Math.Round(europeanOption.theta() / 365, 6);
this.rhoCal_ = Math.Round(europeanOption.rho() / 100, 6);
}
public static object eqInstGetOptionGreeks(
[ExcelArgument(Description = "id of option ")] string ObjectId,
[ExcelArgument(Description = "Greek type ")] string gtype,
[ExcelArgument(Description = "Option type (VANILLA or MULTIASSET)")] string otype,
[ExcelArgument(Description = "trigger ")] object trigger)
{
if (ExcelUtil.CallFromWizard())
{
return("");
}
string callerAddress = "";
callerAddress = ExcelUtil.getActiveCellAddress();
try
{
Xl.Range rng = ExcelUtil.getActiveCellRange();
if (ExcelUtil.isNull(gtype))
{
gtype = "NPV";
}
if (ExcelUtil.isNull(otype))
{
otype = "VANILLA";
}
if (otype == "VANILLA")
{
VanillaOption option = OHRepository.Instance.getObject <VanillaOption>(ObjectId);
switch (gtype.ToUpper())
{
case "NPV":
return(option.NPV());
case "DELTA":
return(option.delta());
case "GAMMA":
return(option.gamma());
case "VEGA":
return(option.vega());
case "THETA":
return(option.theta());
case "RHO":
return(option.rho());
default:
return(0);
}
}
else if (otype == "MULTIASSET")
{
BasketOption option = OHRepository.Instance.getObject <BasketOption>(ObjectId);
switch (gtype.ToUpper())
{
case "NPV":
return(option.NPV());
case "DELTA":
return(option.delta());
case "GAMMA":
return(option.gamma());
case "VEGA":
return(option.vega());
case "THETA":
return(option.theta());
case "RHO":
return(option.rho());
default:
return(0);
}
}
else
{
return("Unknown option type");
}
}
catch (Exception e)
{
ExcelUtil.logError(callerAddress, System.Reflection.MethodInfo.GetCurrentMethod().Name.ToString(), e.Message);
return("#EQ_ERR!");
}
}
