public void testCashOrNothingEuropeanValues()
{
// Testing European cash-or-nothing digital option
DigitalOptionData[] values =
{
// "Option pricing formulas", E.G. Haug, McGraw-Hill 1998 - pag 88
// type, strike, spot, q, r, t, vol, value, tol
new DigitalOptionData(Option.Type.Put, 80.00, 100.0, 0.06, 0.06, 0.75, 0.35, 2.6710, 1e-4, true)
};
DayCounter dc = new Actual360();
Date today = Date.Today;
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 < values.Length; i++)
{
StrikedTypePayoff payoff = new CashOrNothingPayoff(values[i].type, values[i].strike, 10.0);
Date exDate = today + Convert.ToInt32(values[i].t * 360 + 0.5);
Exercise exercise = new EuropeanExercise(exDate);
spot.setValue(values[i].s);
qRate.setValue(values[i].q);
rRate.setValue(values[i].r);
vol.setValue(values[i].v);
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(new Handle <Quote>(spot),
new Handle <YieldTermStructure>(qTS),
new Handle <YieldTermStructure>(rTS),
new Handle <BlackVolTermStructure>(volTS));
IPricingEngine engine = new AnalyticEuropeanEngine(stochProcess);
VanillaOption opt = new VanillaOption(payoff, exercise);
opt.setPricingEngine(engine);
double calculated = opt.NPV();
double error = Math.Abs(calculated - values[i].result);
if (error > values[i].tol)
{
REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q,
values[i].r, today, values[i].v, values[i].result,
calculated, error, values[i].tol, values[i].knockin);
}
}
}
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);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(AnalyticEuropeanEngine obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
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);
}
}
}
}
}
}
}
}
}
}
}
public void testDeltaPriceConsistency()
{
// Testing premium-adjusted delta price consistency
// This function tests for price consistencies with the standard
// Black Scholes calculator, since premium adjusted deltas can be calculated
// from spot deltas by adding/subtracting the premium.
SavedSettings backup = new SavedSettings();
// actually, value and tol won't be needed for testing
EuropeanOptionData[] values =
{
// type, strike, spot, rd, rf, t, vol, value, tol
new EuropeanOptionData(Option.Type.Call, 0.9123, 1.2212, 0.0231, 0.0000, 0.25, 0.301, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 0.9234, 1.2212, 0.0231, 0.0000, 0.35, 0.111, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 0.9783, 1.2212, 0.0231, 0.0000, 0.45, 0.071, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 1.0000, 1.2212, 0.0231, 0.0000, 0.55, 0.082, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 1.1230, 1.2212, 0.0231, 0.0000, 0.65, 0.012, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 1.2212, 1.2212, 0.0231, 0.0000, 0.75, 0.129, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 1.3212, 1.2212, 0.0231, 0.0000, 0.85, 0.034, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 1.3923, 1.2212, 0.0131, 0.2344, 0.95, 0.001, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Call, 1.3455, 1.2212, 0.0000, 0.0000, 1.00, 0.127, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 0.9123, 1.2212, 0.0231, 0.0000, 0.25, 0.301, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 0.9234, 1.2212, 0.0231, 0.0000, 0.35, 0.111, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 0.9783, 1.2212, 0.0231, 0.0000, 0.45, 0.071, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 1.0000, 1.2212, 0.0231, 0.0000, 0.55, 0.082, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 1.1230, 1.2212, 0.0231, 0.0000, 0.65, 0.012, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 1.2212, 1.2212, 0.0231, 0.0000, 0.75, 0.129, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 1.3212, 1.2212, 0.0231, 0.0000, 0.85, 0.034, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 1.3923, 1.2212, 0.0131, 0.2344, 0.95, 0.001, 0.0, 0.0),
new EuropeanOptionData(Option.Type.Put, 1.3455, 1.2212, 0.0000, 0.0000, 1.00, 0.127, 0.0, 0.0),
// extreme case: zero vol
new EuropeanOptionData(Option.Type.Put, 1.3455, 1.2212, 0.0000, 0.0000, 0.50, 0.000, 0.0, 0.0),
// extreme case: zero strike
new EuropeanOptionData(Option.Type.Put, 0.0000, 1.2212, 0.0000, 0.0000, 1.50, 0.133, 0.0, 0.0),
// extreme case: zero strike+zero vol
new EuropeanOptionData(Option.Type.Put, 0.0000, 1.2212, 0.0000, 0.0000, 1.00, 0.133, 0.0, 0.0),
};
DayCounter dc = new Actual360();
Calendar calendar = new TARGET();
Date today = Date.Today;
// Start setup of market data
double discFor = 0.0;
double discDom = 0.0;
double implVol = 0.0;
double expectedVal = 0.0;
double calculatedVal = 0.0;
double error = 0.0;
SimpleQuote spotQuote = new SimpleQuote(0.0);
Handle <Quote> spotHandle = new Handle <Quote>(spotQuote);
SimpleQuote qQuote = new SimpleQuote(0.0);
Handle <Quote> qHandle = new Handle <Quote>(qQuote);
YieldTermStructure qTS = new FlatForward(today, qHandle, dc);
SimpleQuote rQuote = new SimpleQuote(0.0);
Handle <Quote> rHandle = new Handle <Quote>(qQuote);
YieldTermStructure rTS = new FlatForward(today, rHandle, dc);
SimpleQuote volQuote = new SimpleQuote(0.0);
Handle <Quote> volHandle = new Handle <Quote>(volQuote);
BlackVolTermStructure volTS = new BlackConstantVol(today, calendar, volHandle, dc);
BlackScholesMertonProcess stochProcess;
IPricingEngine engine;
StrikedTypePayoff payoff;
Date exDate;
Exercise exercise;
// Setup of market data finished
double tolerance = 1.0e-10;
for (int i = 0; i < values.Length; ++i)
{
payoff = new PlainVanillaPayoff(values[i].type, values[i].strike);
exDate = today + timeToDays(values[i].t);
exercise = new EuropeanExercise(exDate);
spotQuote.setValue(values[i].s);
volQuote.setValue(values[i].v);
rQuote.setValue(values[i].r);
qQuote.setValue(values[i].q);
discDom = rTS.discount(exDate);
discFor = qTS.discount(exDate);
implVol = Math.Sqrt(volTS.blackVariance(exDate, 0.0));
BlackDeltaCalculator myCalc = new BlackDeltaCalculator(values[i].type, DeltaVolQuote.DeltaType.PaSpot,
spotQuote.value(), discDom, discFor, implVol);
stochProcess = new BlackScholesMertonProcess(spotHandle,
new Handle <YieldTermStructure>(qTS),
new Handle <YieldTermStructure>(rTS),
new Handle <BlackVolTermStructure>(volTS));
engine = new AnalyticEuropeanEngine(stochProcess);
EuropeanOption option = new EuropeanOption(payoff, exercise);
option.setPricingEngine(engine);
calculatedVal = myCalc.deltaFromStrike(values[i].strike);
expectedVal = option.delta() - option.NPV() / spotQuote.value();
error = Math.Abs(expectedVal - calculatedVal);
if (error > tolerance)
{
QAssert.Fail("\n Premium-adjusted spot delta test failed. \n"
+ "Calculated Delta: " + calculatedVal + "\n"
+ "Expected Value: " + expectedVal + "\n"
+ "Error: " + error);
}
myCalc.setDeltaType(DeltaVolQuote.DeltaType.PaFwd);
calculatedVal = myCalc.deltaFromStrike(values[i].strike);
expectedVal = expectedVal / discFor; // Premium adjusted Fwd Delta is PA spot without discount
error = Math.Abs(expectedVal - calculatedVal);
if (error > tolerance)
{
QAssert.Fail("\n Premium-adjusted forward delta test failed. \n"
+ "Calculated Delta: " + calculatedVal + "\n"
+ "Expected Value: " + expectedVal + "\n"
+ "Error: " + error);
}
// Test consistency with BlackScholes Calculator for Spot Delta
myCalc.setDeltaType(DeltaVolQuote.DeltaType.Spot);
calculatedVal = myCalc.deltaFromStrike(values[i].strike);
expectedVal = option.delta();
error = Math.Abs(calculatedVal - expectedVal);
if (error > tolerance)
{
QAssert.Fail("\n spot delta in BlackDeltaCalculator differs from delta in BlackScholesCalculator. \n"
+ "Calculated Value: " + calculatedVal + "\n"
+ "Expected Value: " + expectedVal + "\n"
+ "Error: " + error);
}
}
}
public void testEuropeanStartLimit()
{
// Testing dividend European option with a dividend on today's date...
SavedSettings backup = new SavedSettings();
double tolerance = 1.0e-5;
double dividendValue = 10.0;
Option.Type[] types = { 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.00, 0.10, 0.30 };
double[] rRates = { 0.01, 0.05, 0.15 };
int[] lengths = { 1, 2 };
double[] vols = { 0.05, 0.20, 0.70 };
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));
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 + new Period(lengths[k], TimeUnit.Years);
Exercise exercise = new EuropeanExercise(exDate);
List <Date> dividendDates = new List <Date>();
List <double> dividends = new List <double>();
dividendDates.Add(today);
dividends.Add(dividendValue);
StrikedTypePayoff payoff = new PlainVanillaPayoff(types[i], strikes[j]);
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(new Handle <Quote>(spot),
qTS, rTS, volTS);
IPricingEngine engine = new AnalyticDividendEuropeanEngine(stochProcess);
IPricingEngine ref_engine = new AnalyticEuropeanEngine(stochProcess);
DividendVanillaOption option = new DividendVanillaOption(payoff, exercise, dividendDates, dividends);
option.setPricingEngine(engine);
VanillaOption ref_option = new VanillaOption(payoff, exercise);
ref_option.setPricingEngine(ref_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 calculated = option.NPV();
spot.setValue(u - dividendValue);
double expected = ref_option.NPV();
double error = Math.Abs(calculated - expected);
if (error > tolerance)
{
REPORT_FAILURE("value", payoff, exercise,
u, q, r, today, v,
expected, calculated,
error, tolerance);
}
}
}
}
}
}
}
}
}
VanillaOption makeOption(StrikedTypePayoff payoff, Exercise exercise, Quote u, YieldTermStructure q,
YieldTermStructure r, BlackVolTermStructure vol, EngineType engineType, int binomialSteps, int samples)
{
GeneralizedBlackScholesProcess stochProcess = makeProcess(u, q, r, vol);
IPricingEngine engine;
switch (engineType)
{
case EngineType.Analytic:
engine = new AnalyticEuropeanEngine(stochProcess);
break;
case EngineType.JR:
engine = new BinomialVanillaEngine <JarrowRudd>(stochProcess, binomialSteps);
break;
case EngineType.CRR:
engine = new BinomialVanillaEngine <CoxRossRubinstein>(stochProcess, binomialSteps);
break;
case EngineType.EQP:
engine = new BinomialVanillaEngine <AdditiveEQPBinomialTree>(stochProcess, binomialSteps);
break;
case EngineType.TGEO:
engine = new BinomialVanillaEngine <Trigeorgis>(stochProcess, binomialSteps);
break;
case EngineType.TIAN:
engine = new BinomialVanillaEngine <Tian>(stochProcess, binomialSteps);
break;
case EngineType.LR:
engine = new BinomialVanillaEngine <LeisenReimer>(stochProcess, binomialSteps);
break;
case EngineType.JOSHI:
engine = new BinomialVanillaEngine <Joshi4>(stochProcess, binomialSteps);
break;
case EngineType.FiniteDifferences:
engine = new FDEuropeanEngine(stochProcess, binomialSteps, samples);
break;
case EngineType.Integral:
engine = new IntegralEngine(stochProcess);
break;
//case EngineType.PseudoMonteCarlo:
// engine = MakeMCEuropeanEngine<PseudoRandom>(stochProcess)
// .withSteps(1)
// .withSamples(samples)
// .withSeed(42);
// break;
//case EngineType.QuasiMonteCarlo:
// engine = MakeMCEuropeanEngine<LowDiscrepancy>(stochProcess)
// .withSteps(1)
// .withSamples(samples);
// break;
default:
throw new ArgumentException("unknown engine type");
}
VanillaOption option = new EuropeanOption(payoff, exercise);
option.setPricingEngine(engine);
return(option);
}
public void testBsmHullWhiteEngine()
{
// Testing European option pricing for a BSM process with one-factor Hull-White model
DayCounter dc = new Actual365Fixed();
Date today = Date.Today;
Date maturity = today + new Period(20, TimeUnit.Years);
Settings.Instance.setEvaluationDate(today);
Handle <Quote> spot = new Handle <Quote>(new SimpleQuote(100.0));
SimpleQuote qRate = new SimpleQuote(0.04);
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(Utilities.flatRate(today, qRate, dc));
SimpleQuote rRate = new SimpleQuote(0.0525);
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(Utilities.flatRate(today, rRate, dc));
SimpleQuote vol = new SimpleQuote(0.25);
Handle <BlackVolTermStructure> volTS = new Handle <BlackVolTermStructure>(Utilities.flatVol(today, vol, dc));
// FLOATING_POINT_EXCEPTION
HullWhite hullWhiteModel = new HullWhite(new Handle <YieldTermStructure>(rTS), 0.00883, 0.00526);
BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(spot, qTS, rTS, volTS);
Exercise exercise = new EuropeanExercise(maturity);
double fwd = spot.link.value() * qTS.link.discount(maturity) / rTS.link.discount(maturity);
StrikedTypePayoff payoff = new PlainVanillaPayoff(Option.Type.Call, fwd);
EuropeanOption option = new EuropeanOption(payoff, exercise);
double tol = 1e-8;
double[] corr = { -0.75, -0.25, 0.0, 0.25, 0.75 };
double[] expectedVol = { 0.217064577, 0.243995801, 0.256402830, 0.268236596, 0.290461343 };
for (int i = 0; i < corr.Length; ++i)
{
IPricingEngine bsmhwEngine = new AnalyticBSMHullWhiteEngine(corr[i], stochProcess, hullWhiteModel);
option.setPricingEngine(bsmhwEngine);
double npv = option.NPV();
Handle <BlackVolTermStructure> compVolTS = new Handle <BlackVolTermStructure>(
Utilities.flatVol(today, expectedVol[i], dc));
BlackScholesMertonProcess bsProcess = new BlackScholesMertonProcess(spot, qTS, rTS, compVolTS);
IPricingEngine bsEngine = new AnalyticEuropeanEngine(bsProcess);
EuropeanOption comp = new EuropeanOption(payoff, exercise);
comp.setPricingEngine(bsEngine);
double impliedVol = comp.impliedVolatility(npv, bsProcess, 1e-10, 100);
if (Math.Abs(impliedVol - expectedVol[i]) > tol)
{
QAssert.Fail("Failed to reproduce implied volatility"
+ "\n calculated: " + impliedVol
+ "\n expected : " + expectedVol[i]);
}
if (Math.Abs((comp.NPV() - npv) / npv) > tol)
{
QAssert.Fail("Failed to reproduce NPV"
+ "\n calculated: " + npv
+ "\n expected : " + comp.NPV());
}
if (Math.Abs(comp.delta() - option.delta()) > tol)
{
QAssert.Fail("Failed to reproduce NPV"
+ "\n calculated: " + npv
+ "\n expected : " + comp.NPV());
}
if (Math.Abs((comp.gamma() - option.gamma()) / npv) > tol)
{
QAssert.Fail("Failed to reproduce NPV"
+ "\n calculated: " + npv
+ "\n expected : " + comp.NPV());
}
if (Math.Abs((comp.theta() - option.theta()) / npv) > tol)
{
QAssert.Fail("Failed to reproduce NPV"
+ "\n calculated: " + npv
+ "\n expected : " + comp.NPV());
}
if (Math.Abs((comp.vega() - option.vega()) / npv) > tol)
{
QAssert.Fail("Failed to reproduce NPV"
+ "\n calculated: " + npv
+ "\n expected : " + comp.NPV());
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(AnalyticEuropeanEngine obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
