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);
}
}
public void testCashOrNothingHaugValues()
{
// Testing cash-or-nothing barrier options against Haug's values
BinaryOptionData[] values =
{
/* The data below are from
* "Option pricing formulas 2nd Ed.", E.G. Haug, McGraw-Hill 2007 pag. 180 - cases 13,14,17,18,21,22,25,26
* Note:
* q is the dividend rate, while the book gives b, the cost of carry (q=r-b)
*/
// barrierType, barrier, cash, type, strike, spot, q, r, t, vol, value, tol
new BinaryOptionData(Barrier.Type.DownIn, 100.00, 15.00, Option.Type.Call, 102.00, 105.00, 0.00, 0.10, 0.5, 0.20, 4.9289, 1e-4),
new BinaryOptionData(Barrier.Type.DownIn, 100.00, 15.00, Option.Type.Call, 98.00, 105.00, 0.00, 0.10, 0.5, 0.20, 6.2150, 1e-4),
// following value is wrong in book.
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Call, 102.00, 95.00, 0.00, 0.10, 0.5, 0.20, 5.8926, 1e-4),
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Call, 98.00, 95.00, 0.00, 0.10, 0.5, 0.20, 7.4519, 1e-4),
// 17,18
new BinaryOptionData(Barrier.Type.DownIn, 100.00, 15.00, Option.Type.Put, 102.00, 105.00, 0.00, 0.10, 0.5, 0.20, 4.4314, 1e-4),
new BinaryOptionData(Barrier.Type.DownIn, 100.00, 15.00, Option.Type.Put, 98.00, 105.00, 0.00, 0.10, 0.5, 0.20, 3.1454, 1e-4),
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Put, 102.00, 95.00, 0.00, 0.10, 0.5, 0.20, 5.3297, 1e-4),
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Put, 98.00, 95.00, 0.00, 0.10, 0.5, 0.20, 3.7704, 1e-4),
// 21,22
new BinaryOptionData(Barrier.Type.DownOut, 100.00, 15.00, Option.Type.Call, 102.00, 105.00, 0.00, 0.10, 0.5, 0.20, 4.8758, 1e-4),
new BinaryOptionData(Barrier.Type.DownOut, 100.00, 15.00, Option.Type.Call, 98.00, 105.00, 0.00, 0.10, 0.5, 0.20, 4.9081, 1e-4),
new BinaryOptionData(Barrier.Type.UpOut, 100.00, 15.00, Option.Type.Call, 102.00, 95.00, 0.00, 0.10, 0.5, 0.20, 0.0000, 1e-4),
new BinaryOptionData(Barrier.Type.UpOut, 100.00, 15.00, Option.Type.Call, 98.00, 95.00, 0.00, 0.10, 0.5, 0.20, 0.0407, 1e-4),
// 25,26
new BinaryOptionData(Barrier.Type.DownOut, 100.00, 15.00, Option.Type.Put, 102.00, 105.00, 0.00, 0.10, 0.5, 0.20, 0.0323, 1e-4),
new BinaryOptionData(Barrier.Type.DownOut, 100.00, 15.00, Option.Type.Put, 98.00, 105.00, 0.00, 0.10, 0.5, 0.20, 0.0000, 1e-4),
new BinaryOptionData(Barrier.Type.UpOut, 100.00, 15.00, Option.Type.Put, 102.00, 95.00, 0.00, 0.10, 0.5, 0.20, 3.0461, 1e-4),
new BinaryOptionData(Barrier.Type.UpOut, 100.00, 15.00, Option.Type.Put, 98.00, 95.00, 0.00, 0.10, 0.5, 0.20, 3.0054, 1e-4),
// other values calculated with book vba
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Call, 102.00, 95.00, -0.14, 0.10, 0.5, 0.20, 8.6806, 1e-4),
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Call, 102.00, 95.00, 0.03, 0.10, 0.5, 0.20, 5.3112, 1e-4),
// degenerate conditions (barrier touched)
new BinaryOptionData(Barrier.Type.DownIn, 100.00, 15.00, Option.Type.Call, 98.00, 95.00, 0.00, 0.10, 0.5, 0.20, 7.4926, 1e-4),
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Call, 98.00, 105.00, 0.00, 0.10, 0.5, 0.20, 11.1231, 1e-4),
// 17,18
new BinaryOptionData(Barrier.Type.DownIn, 100.00, 15.00, Option.Type.Put, 102.00, 98.00, 0.00, 0.10, 0.5, 0.20, 7.1344, 1e-4),
new BinaryOptionData(Barrier.Type.UpIn, 100.00, 15.00, Option.Type.Put, 102.00, 101.00, 0.00, 0.10, 0.5, 0.20, 5.9299, 1e-4),
// 21,22
new BinaryOptionData(Barrier.Type.DownOut, 100.00, 15.00, Option.Type.Call, 98.00, 99.00, 0.00, 0.10, 0.5, 0.20, 0.0000, 1e-4),
new BinaryOptionData(Barrier.Type.UpOut, 100.00, 15.00, Option.Type.Call, 98.00, 101.00, 0.00, 0.10, 0.5, 0.20, 0.0000, 1e-4),
// 25,26
new BinaryOptionData(Barrier.Type.DownOut, 100.00, 15.00, Option.Type.Put, 98.00, 99.00, 0.00, 0.10, 0.5, 0.20, 0.0000, 1e-4),
new BinaryOptionData(Barrier.Type.UpOut, 100.00, 15.00, Option.Type.Put, 98.00, 101.00, 0.00, 0.10, 0.5, 0.20, 0.0000, 1e-4),
};
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(100.0);
SimpleQuote qRate = new SimpleQuote(0.04);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.01);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.25);
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, values[i].cash);
Date exDate = today + Convert.ToInt32(values[i].t * 360 + 0.5);
Exercise amExercise = new AmericanExercise(today, exDate, true);
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 AnalyticBinaryBarrierEngine(stochProcess);
BarrierOption opt = new BarrierOption(values[i].barrierType, values[i].barrier, 0, payoff, amExercise);
opt.setPricingEngine(engine);
double calculated = opt.NPV();
double error = Math.Abs(calculated - values[i].result);
if (error > values[i].tol)
{
REPORT_FAILURE("value", payoff, amExercise, values[i].barrierType,
values[i].barrier, values[i].s,
values[i].q, values[i].r, today, values[i].v,
values[i].result, calculated, error, values[i].tol);
}
}
}
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 testCashAtExpiryOrNothingAmericanValues()
{
// Testing American cash-(at-expiry)-or-nothing digital option
DigitalOptionData[] values =
{
// type, strike, spot, q, r, t, vol, value, tol
// "Option pricing formulas", E.G. Haug, McGraw-Hill 1998 - pag 95, case 5,6,9,10
new DigitalOptionData(Option.Type.Put, 100.00, 105.00, 0.00, 0.10, 0.5, 0.20, 9.3604, 1e-4, true),
new DigitalOptionData(Option.Type.Call, 100.00, 95.00, 0.00, 0.10, 0.5, 0.20, 11.2223, 1e-4, true),
new DigitalOptionData(Option.Type.Put, 100.00, 105.00, 0.00, 0.10, 0.5, 0.20, 4.9081, 1e-4, false),
new DigitalOptionData(Option.Type.Call, 100.00, 95.00, 0.00, 0.10, 0.5, 0.20, 3.0461, 1e-4, false),
// in the money options (guaranteed discounted payoff)
new DigitalOptionData(Option.Type.Call, 100.00, 105.00, 0.00, 0.10, 0.5, 0.20, 15.0000 * Math.Exp(-0.05), 1e-12, true),
new DigitalOptionData(Option.Type.Put, 100.00, 95.00, 0.00, 0.10, 0.5, 0.20, 15.0000 * Math.Exp(-0.05), 1e-12, true),
// out of bonds case
new DigitalOptionData(Option.Type.Call, 2.37, 2.33, 0.07, 0.43, 0.19, 0.005, 0.0000, 1e-4, false),
};
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(100.0);
SimpleQuote qRate = new SimpleQuote(0.04);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.01);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.25);
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, 15.0);
Date exDate = today + Convert.ToInt32(values[i].t * 360 + 0.5);
Exercise amExercise = new AmericanExercise(today, exDate, true);
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;
if (values[i].knockin)
{
engine = new AnalyticDigitalAmericanEngine(stochProcess);
}
else
{
engine = new AnalyticDigitalAmericanKOEngine(stochProcess);
}
VanillaOption opt = new VanillaOption(payoff, amExercise);
opt.setPricingEngine(engine);
double calculated = opt.NPV();
double error = Math.Abs(calculated - values[i].result);
if (error > values[i].tol)
{
REPORT_FAILURE("value", payoff, amExercise, 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 testCashAtHitOrNothingAmericanValues()
{
// Testing American cash-(at-hit)-or-nothing digital option
DigitalOptionData[] values =
{
// type, strike, spot, q, r, t, vol, value, tol
// "Option pricing formulas", E.G. Haug, McGraw-Hill 1998 - pag 95, case 1,2
new DigitalOptionData(Option.Type.Put, 100.00, 105.00, 0.00, 0.10, 0.5, 0.20, 9.7264, 1e-4, true),
new DigitalOptionData(Option.Type.Call, 100.00, 95.00, 0.00, 0.10, 0.5, 0.20, 11.6553, 1e-4, true),
// the following cases are not taken from a reference paper or book
// in the money options (guaranteed immediate payoff)
new DigitalOptionData(Option.Type.Call, 100.00, 105.00, 0.00, 0.10, 0.5, 0.20, 15.0000, 1e-16, true),
new DigitalOptionData(Option.Type.Put, 100.00, 95.00, 0.00, 0.10, 0.5, 0.20, 15.0000, 1e-16, true),
// non null dividend (cross-tested with MC simulation)
new DigitalOptionData(Option.Type.Put, 100.00, 105.00, 0.20, 0.10, 0.5, 0.20, 12.2715, 1e-4, true),
new DigitalOptionData(Option.Type.Call, 100.00, 95.00, 0.20, 0.10, 0.5, 0.20, 8.9109, 1e-4, true),
new DigitalOptionData(Option.Type.Call, 100.00, 105.00, 0.20, 0.10, 0.5, 0.20, 15.0000, 1e-16, true),
new DigitalOptionData(Option.Type.Put, 100.00, 95.00, 0.20, 0.10, 0.5, 0.20, 15.0000, 1e-16, 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, 15.00);
Date exDate = today + Convert.ToInt32(values[i].t * 360 + 0.5);
Exercise amExercise = new AmericanExercise(today, 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 AnalyticDigitalAmericanEngine(stochProcess);
VanillaOption opt = new VanillaOption(payoff, amExercise);
opt.setPricingEngine(engine);
double calculated = opt.NPV();
double error = Math.Abs(calculated - values[i].result);
if (error > values[i].tol)
{
REPORT_FAILURE("value", payoff, amExercise, 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 testHaugValues()
{
// Testing cash-or-nothing double barrier options against Haug's values
DoubleBinaryOptionData[] values =
{
/* The data below are from
* "Option pricing formulas 2nd Ed.", E.G. Haug, McGraw-Hill 2007 pag. 181
* Note: book uses cost of carry b, instead of dividend rate q
*/
// barrierType, bar_lo, bar_hi, cash, spot, q, r, t, vol, value, tol
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 9.8716, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 8.9307, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 6.3272, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 1.9094, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 9.7961, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 7.2300, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 3.7100, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 0.4271, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 8.9054, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 3.6752, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 0.7960, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 0.0059, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 3.6323, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 0.0911, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 0.0002, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 0.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 0.2402, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 1.4076, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 3.8160, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.0075, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 0.9910, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 2.8098, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 4.6612, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.2656, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 2.7954, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 4.4024, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 4.9266, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 2.6285, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 4.7523, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 4.9096, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 4.9675, 1e-4),
// following values calculated with haug's VBA code
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.0042, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 0.9450, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 3.5486, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 7.9663, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.0797, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 2.6458, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 6.1658, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 9.4486, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.9704, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 6.2006, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 9.0798, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 9.8699, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 6.2434, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 9.7847, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 9.8756, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 9.8758, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.0041, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 0.7080, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 2.1581, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 80.00, 120.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 4.2061, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.0723, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 1.6663, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 3.3930, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 85.00, 115.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 4.8679, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 0.7080, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 3.4424, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 4.7496, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 90.00, 110.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 5.0475, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.10, 3.6524, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.20, 5.1256, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.30, 5.0763, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 95.00, 105.00, 10.00, 100.00, 0.02, 0.05, 0.25, 0.50, 5.0275, 1e-4),
// degenerate cases
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 95.00, 105.00, 10.00, 80.00, 0.02, 0.05, 0.25, 0.10, 0.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockOut, 95.00, 105.00, 10.00, 110.00, 0.02, 0.05, 0.25, 0.10, 0.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 95.00, 105.00, 10.00, 80.00, 0.02, 0.05, 0.25, 0.10, 10.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KnockIn, 95.00, 105.00, 10.00, 110.00, 0.02, 0.05, 0.25, 0.10, 10.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 95.00, 105.00, 10.00, 80.00, 0.02, 0.05, 0.25, 0.10, 10.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KIKO, 95.00, 105.00, 10.00, 110.00, 0.02, 0.05, 0.25, 0.10, 0.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 95.00, 105.00, 10.00, 80.00, 0.02, 0.05, 0.25, 0.10, 0.0000, 1e-4),
new DoubleBinaryOptionData(DoubleBarrier.Type.KOKI, 95.00, 105.00, 10.00, 110.00, 0.02, 0.05, 0.25, 0.10, 10.0000, 1e-4),
};
DayCounter dc = new Actual360();
Date today = Date.Today;
SimpleQuote spot = new SimpleQuote(100.0);
SimpleQuote qRate = new SimpleQuote(0.04);
YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc);
SimpleQuote rRate = new SimpleQuote(0.01);
YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc);
SimpleQuote vol = new SimpleQuote(0.25);
BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc);
for (int i = 0; i < values.Length; i++)
{
StrikedTypePayoff payoff = new CashOrNothingPayoff(Option.Type.Call, 0, values[i].cash);
Date exDate = today + Convert.ToInt32(values[i].t * 360 + 0.5);
Exercise exercise;
if (values[i].barrierType == DoubleBarrier.Type.KIKO ||
values[i].barrierType == DoubleBarrier.Type.KOKI)
{
exercise = new AmericanExercise(today, exDate, true);
}
else
{
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 AnalyticDoubleBarrierBinaryEngine(stochProcess);
DoubleBarrierOption opt = new DoubleBarrierOption(values[i].barrierType,
values[i].barrier_lo,
values[i].barrier_hi,
0,
payoff,
exercise);
opt.setPricingEngine(engine);
double calculated = opt.NPV();
double expected = values[i].result;
double error = Math.Abs(calculated - values[i].result);
if (error > values[i].tol)
{
REPORT_FAILURE("value", payoff, exercise, values[i].barrierType,
values[i].barrier_lo, values[i].barrier_hi, values[i].s,
values[i].q, values[i].r, today, values[i].v,
values[i].result, calculated, error, values[i].tol);
}
int steps = 500;
// checking with binomial engine
engine = new BinomialDoubleBarrierEngine(
(d, end, step, strike) => new CoxRossRubinstein(d, end, step, strike),
(args, process, grid) => new DiscretizedDoubleBarrierOption(args, process, grid),
stochProcess, steps);
opt.setPricingEngine(engine);
calculated = opt.NPV();
expected = values[i].result;
error = Math.Abs(calculated - expected);
double tol = 0.22;
if (error > tol)
{
REPORT_FAILURE("Binomial value", payoff, exercise, values[i].barrierType,
values[i].barrier_lo, values[i].barrier_hi, values[i].s,
values[i].q, values[i].r, today, values[i].v,
values[i].result, calculated, error, tol);
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CashOrNothingPayoff obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CashOrNothingPayoff obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
