public DVPLI.EstimationResult Estimate(List <object> data, DVPLI.IEstimationSettings settings = null, DVPLI.IController controller = null, Dictionary <string, object> properties = null)
{
DVPLI.InterestRateMarketData irmd = data[0] as DVPLI.InterestRateMarketData;
//Date today = new Date(15, Month.February, 2002);
//Date settlement = new Date(19, Month.February, 2002);
Settings.setEvaluationDate(irmd.Date);
Handle <YieldTermStructure> termStructure = new Handle <YieldTermStructure>(new Utilities.ZeroRateFunction(irmd.Date, irmd.ZRMarketDates, irmd.ZRMarket));
//termStructure.link
HullWhite model = new HullWhite(termStructure);
IborIndex index = new Euribor6M(termStructure);
IPricingEngine engine = new JamshidianSwaptionEngine(model);
List <CalibrationHelper> swaptions = new List <CalibrationHelper>();
for (int i = 0; i < irmd.SwapDates.Length; i++)
{
for (int j = 0; j < irmd.SwapDuration.Length; j++)
{
Quote vol = new SimpleQuote(irmd.SwaptionsVolatility[j, i]);
CalibrationHelper helper =
new SwaptionHelper(new Period((int)irmd.SwapDates[i], TimeUnit.Years),
new Period((int)irmd.SwapDuration[j], TimeUnit.Years),
new Handle <Quote>(vol),
index,
new Period(1, TimeUnit.Years),
new Thirty360(),
new Actual360(),
termStructure,
false);
helper.setPricingEngine(engine);
swaptions.Add(helper);
}
}
// Set up the optimization problem
LevenbergMarquardt optimizationMethod = new LevenbergMarquardt(1.0e-8, 1.0e-8, 1.0e-8);
EndCriteria endCriteria = new EndCriteria(10000, 100, 1e-6, 1e-8, 1e-8);
//Optimize
model.calibrate(swaptions, optimizationMethod, endCriteria, new Constraint(), new List <double>());
EndCriteria.Type ecType = model.endCriteria();
Vector xMinCalculated = model.parameters();
double yMinCalculated = model.value(xMinCalculated, swaptions);
Vector xMinExpected = new Vector(2);
double yMinExpected = model.value(xMinExpected, swaptions);
DVPLI.EstimationResult r = new DVPLI.EstimationResult(new string[] { "Alpha", "Sigma" }, new double[] { xMinCalculated[0], xMinCalculated[1] });
return(r);
}
public FdHullWhiteSwaptionEngine(HullWhite model) : this(NQuantLibcPINVOKE.new_FdHullWhiteSwaptionEngine__SWIG_5(HullWhite.getCPtr(model)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public void testFuturesConvexityBias()
{
//BOOST_MESSAGE("Testing Hull-White futures convexity bias...");
// G. Kirikos, D. Novak, "Convexity Conundrums", Risk Magazine, March 1997
double futureQuote = 94.0;
double a = 0.03;
double sigma = 0.015;
double t = 5.0;
double T = 5.25;
double expectedForward = 0.0573037;
double tolerance = 0.0000001;
double futureImpliedRate = (100.0 - futureQuote) / 100.0;
double calculatedForward =
futureImpliedRate - HullWhite.convexityBias(futureQuote, t, T, sigma, a);
double error = Math.Abs(calculatedForward - expectedForward);
if (error > tolerance)
{
Assert.Fail("Failed to reproduce convexity bias:"
+ "\ncalculated: " + calculatedForward
+ "\n expected: " + expectedForward
//+ QL_SCIENTIFIC
+ "\n error: " + error
+ "\n tolerance: " + tolerance);
}
}
public FdHullWhiteSwaptionEngine(HullWhite model, uint tGrid, uint xGrid, uint dampingSteps, double invEps, FdmSchemeDesc schemeDesc) : this(NQuantLibcPINVOKE.new_FdHullWhiteSwaptionEngine__SWIG_0(HullWhite.getCPtr(model), tGrid, xGrid, dampingSteps, invEps, FdmSchemeDesc.getCPtr(schemeDesc)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public FdHullWhiteSwaptionEngine(HullWhite model, uint tGrid, uint xGrid, uint dampingSteps) : this(NQuantLibcPINVOKE.new_FdHullWhiteSwaptionEngine__SWIG_2(HullWhite.getCPtr(model), tGrid, xGrid, dampingSteps), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
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());
}
}
}
public void testSwaps()
{
//BOOST_MESSAGE("Testing Hull-White swap pricing against known values...");
Date today; //=Settings::instance().evaluationDate();;
Calendar calendar = new TARGET();
today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
Date settlement = calendar.advance(today, 2, TimeUnit.Days);
Date[] dates =
{
settlement,
calendar.advance(settlement, 1, TimeUnit.Weeks),
calendar.advance(settlement, 1, TimeUnit.Months),
calendar.advance(settlement, 3, TimeUnit.Months),
calendar.advance(settlement, 6, TimeUnit.Months),
calendar.advance(settlement, 9, TimeUnit.Months),
calendar.advance(settlement, 1, TimeUnit.Years),
calendar.advance(settlement, 2, TimeUnit.Years),
calendar.advance(settlement, 3, TimeUnit.Years),
calendar.advance(settlement, 5, TimeUnit.Years),
calendar.advance(settlement, 10, TimeUnit.Years),
calendar.advance(settlement, 15, TimeUnit.Years)
};
double[] discounts =
{
1.0,
0.999258,
0.996704,
0.990809,
0.981798,
0.972570,
0.963430,
0.929532,
0.889267,
0.803693,
0.596903,
0.433022
};
//for (int i = 0; i < dates.Length; i++)
// dates[i] + dates.Length;
LogLinear Interpolator = new LogLinear();
Handle <YieldTermStructure> termStructure =
new Handle <YieldTermStructure>(
new InterpolatedDiscountCurve <LogLinear>(
dates.ToList <Date>(),
discounts.ToList <double>(),
new Actual365Fixed(), new Calendar(), null, null, Interpolator)
);
HullWhite model = new HullWhite(termStructure);
int[] start = { -3, 0, 3 };
int[] length = { 2, 5, 10 };
double[] rates = { 0.02, 0.04, 0.06 };
IborIndex euribor = new Euribor6M(termStructure);
IPricingEngine engine = new TreeVanillaSwapEngine(model, 120, termStructure);
#if QL_USE_INDEXED_COUPON
double tolerance = 4.0e-3;
#else
double tolerance = 1.0e-8;
#endif
for (int i = 0; i < start.Length; i++)
{
Date startDate = calendar.advance(settlement, start[i], TimeUnit.Months);
if (startDate < today)
{
Date fixingDate = calendar.advance(startDate, -2, TimeUnit.Days);
//TimeSeries<double> pastFixings;
ObservableValue <TimeSeries <double> > pastFixings = new ObservableValue <TimeSeries <double> >();
pastFixings.value()[fixingDate] = 0.03;
IndexManager.instance().setHistory(euribor.name(),
pastFixings);
}
for (int j = 0; j < length.Length; j++)
{
Date maturity = calendar.advance(startDate, length[i], TimeUnit.Years);
Schedule fixedSchedule = new Schedule(startDate, maturity, new Period(Frequency.Annual),
calendar, BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(startDate, maturity, new Period(Frequency.Semiannual),
calendar, BusinessDayConvention.Following, BusinessDayConvention.Following,
DateGeneration.Rule.Forward, false);
for (int k = 0; k < rates.Length; k++)
{
VanillaSwap swap = new VanillaSwap(VanillaSwap.Type.Payer, 1000000.0,
fixedSchedule, rates[k], new Thirty360(),
floatSchedule, euribor, 0.0, new Actual360());
swap.setPricingEngine(new DiscountingSwapEngine(termStructure));
double expected = swap.NPV();
swap.setPricingEngine(engine);
double calculated = swap.NPV();
double error = Math.Abs((expected - calculated) / expected);
if (error > tolerance)
{
Assert.Fail("Failed to reproduce swap NPV:"
//+ QL_FIXED << std::setprecision(9)
+ "\n calculated: " + calculated
+ "\n expected: " + expected
//+ QL_SCIENTIFIC
+ "\n rel. error: " + error);
}
}
}
}
}
public void testCachedValues()
{
//("Testing Bermudan swaption against cached values...");
CommonVars vars = new CommonVars();
vars.today = new Date(15, Month.February, 2002);
Settings.setEvaluationDate(vars.today);
vars.settlement = new Date(19, Month.February, 2002);
// flat yield term structure impling 1x5 swap at 5%
vars.termStructure.linkTo(Utilities.flatRate(vars.settlement,
0.04875825,
new Actual365Fixed()));
double atmRate = vars.makeSwap(0.0).fairRate();
VanillaSwap itmSwap = vars.makeSwap(0.8 * atmRate);
VanillaSwap atmSwap = vars.makeSwap(atmRate);
VanillaSwap otmSwap = vars.makeSwap(1.2 * atmRate);
double a = 0.048696, sigma = 0.0058904;
ShortRateModel model = new HullWhite(vars.termStructure, a, sigma);
List <Date> exerciseDates = new List <Date>();
List <CashFlow> leg = atmSwap.fixedLeg();
for (int i = 0; i < leg.Count; i++)
{
Coupon coupon = (Coupon)(leg[i]);
exerciseDates.Add(coupon.accrualStartDate());
}
Exercise exercise = new BermudanExercise(exerciseDates);
IPricingEngine treeEngine = new TreeSwaptionEngine(model, 50);
IPricingEngine fdmEngine = new FdHullWhiteSwaptionEngine(model as HullWhite);
#if QL_USE_INDEXED_COUPON
double itmValue = 42.2413, atmValue = 12.8789, otmValue = 2.4759;
double itmValueFdm = 42.2111, atmValueFdm = 12.8879, otmValueFdm = 2.44443;
#else
double itmValue = 42.2470, atmValue = 12.8826, otmValue = 2.4769;
double itmValueFdm = 42.2091, atmValueFdm = 12.8864, otmValueFdm = 2.4437;
#endif
double tolerance = 1.0e-4;
Swaption swaption = new Swaption(itmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - itmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValue);
}
swaption.setPricingEngine(fdmEngine);
if (Math.Abs(swaption.NPV() - itmValueFdm) > tolerance)
{
QAssert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValueFdm);
}
swaption = new Swaption(atmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - atmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValue);
}
swaption.setPricingEngine(fdmEngine);
if (Math.Abs(swaption.NPV() - atmValueFdm) > tolerance)
{
QAssert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValueFdm);
}
swaption = new Swaption(otmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - otmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValue);
}
swaption.setPricingEngine(fdmEngine);
if (Math.Abs(swaption.NPV() - otmValueFdm) > tolerance)
{
QAssert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValueFdm);
}
for (int j = 0; j < exerciseDates.Count; j++)
{
exerciseDates[j] = vars.calendar.adjust(exerciseDates[j] - 10);
}
exercise = new BermudanExercise(exerciseDates);
#if QL_USE_INDEXED_COUPON
itmValue = 42.1917; atmValue = 12.7788; otmValue = 2.4388;
#else
itmValue = 42.1974; atmValue = 12.7825; otmValue = 2.4399;
#endif
swaption = new Swaption(itmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - itmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValue);
}
swaption = new Swaption(atmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - atmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValue);
}
swaption = new Swaption(otmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - otmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValue);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HullWhite obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
private static void Main()
{
DateTime startTime = DateTime.Now;
var todaysDate = new DateTime(2002, 2, 15);
Settings.instance().setEvaluationDate(todaysDate);
Calendar calendar = new TARGET();
var settlementDate = new Date(19, Month.February, 2002);
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
var myTermStructure = new FlatForward(settlementDate, new QuoteHandle(flatRate), new Actual365Fixed());
var rhTermStructure = new RelinkableYieldTermStructureHandle();
rhTermStructure.linkTo(myTermStructure);
// Define the ATM/OTM/ITM swaps
var fixedLegTenor = new Period(1, TimeUnit.Years);
const BusinessDayConvention fixedLegConvention = BusinessDayConvention.Unadjusted;
const BusinessDayConvention floatingLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new Thirty360(Thirty360.Convention.European);
var floatingLegTenor = new Period(6, TimeUnit.Months);
const double dummyFixedRate = 0.03;
IborIndex indexSixMonths = new Euribor6M(rhTermStructure);
Date startDate = calendar.advance(settlementDate, 1, TimeUnit.Years, floatingLegConvention);
Date maturity = calendar.advance(startDate, 5, TimeUnit.Years, floatingLegConvention);
var fixedSchedule = new Schedule(startDate, maturity, fixedLegTenor, calendar, fixedLegConvention, fixedLegConvention, DateGeneration.Rule.Forward, false);
var floatSchedule = new Schedule(startDate, maturity, floatingLegTenor, calendar, floatingLegConvention, floatingLegConvention, DateGeneration.Rule.Forward, false);
var swap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0, indexSixMonths.dayCounter());
var swapEngine = new DiscountingSwapEngine(rhTermStructure);
swap.setPricingEngine(swapEngine);
double fixedAtmRate = swap.fairRate();
double fixedOtmRate = fixedAtmRate * 1.2;
double fixedItmRate = fixedAtmRate * 0.8;
var atmSwap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedAtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
var otmSwap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedOtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
var itmSwap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedItmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
atmSwap.setPricingEngine(swapEngine);
otmSwap.setPricingEngine(swapEngine);
itmSwap.setPricingEngine(swapEngine);
// defining the swaptions to be used in model calibration
var swaptionMaturities = new PeriodVector
{
new Period(1, TimeUnit.Years),
new Period(2, TimeUnit.Years),
new Period(3, TimeUnit.Years),
new Period(4, TimeUnit.Years),
new Period(5, TimeUnit.Years)
};
var swaptions = new CalibrationHelperVector();
// List of times that have to be included in the timegrid
var times = new DoubleVector();
for (int i = 0; i < NUM_ROWS; i++)
{
int j = NUM_COLS - i - 1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i * NUM_COLS + j;
Quote vol = new SimpleQuote(SWAPTION_VOLS[k]);
var helper = new SwaptionHelper(swaptionMaturities[i], new Period(SWAP_LENGHTS[j], TimeUnit.Years),
new QuoteHandle(vol),
indexSixMonths, indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure);
swaptions.Add(helper);
times.AddRange(helper.times());
}
// Building time-grid
var grid = new TimeGrid(times, 30);
// defining the models
// G2 modelG2 = new G2(rhTermStructure));
var modelHw = new HullWhite(rhTermStructure);
var modelHw2 = new HullWhite(rhTermStructure);
var modelBk = new BlackKarasinski(rhTermStructure);
// model calibrations
Console.WriteLine("Hull-White (analytic formulae) calibration");
foreach (CalibrationHelper calibrationHelper in swaptions)
{
NQuantLibc.as_black_helper(calibrationHelper).setPricingEngine(new JamshidianSwaptionEngine(modelHw));
}
CalibrateModel(modelHw, swaptions, 0.05);
Console.WriteLine("Hull-White (numerical) calibration");
foreach (CalibrationHelper calibrationHelper in swaptions)
{
NQuantLibc.as_black_helper(calibrationHelper).setPricingEngine(new TreeSwaptionEngine(modelHw2, grid));
}
CalibrateModel(modelHw2, swaptions, 0.05);
Console.WriteLine("Black-Karasinski (numerical) calibration");
foreach (CalibrationHelper calibrationHelper in swaptions)
{
NQuantLibc.as_black_helper(calibrationHelper).setPricingEngine(new TreeSwaptionEngine(modelBk, grid));
}
CalibrateModel(modelBk, swaptions, 0.05);
// ATM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption struck at {0} (ATM)", fixedAtmRate);
var bermudanDates = new DateVector();
var schedule = new Schedule(startDate, maturity,
new Period(3, TimeUnit.Months), calendar,
BusinessDayConvention.Following,
BusinessDayConvention.Following,
DateGeneration.Rule.Forward, false);
for (uint i = 0; i < schedule.size(); i++)
{
bermudanDates.Add(schedule.date(i));
}
Exercise bermudaExercise = new BermudanExercise(bermudanDates);
var bermudanSwaption = new Swaption(atmSwap, bermudaExercise);
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK (num): " + bermudanSwaption.NPV());
DateTime endTime = DateTime.Now;
TimeSpan delta = endTime - startTime;
Console.WriteLine();
Console.WriteLine("Run completed in {0} s", delta.TotalSeconds);
Console.WriteLine();
}
public void testH1HWPricingEngine()
{
/*
* Example taken from Lech Aleksander Grzelak,
* Equity and Foreign Exchange Hybrid Models for Pricing Long-Maturity
* Financial Derivatives,
* http://repository.tudelft.nl/assets/uuid:a8e1a007-bd89-481a-aee3-0e22f15ade6b/PhDThesis_main.pdf
*/
Date today = new Date(15, Month.July, 2012);
Settings.Instance.setEvaluationDate(today);
Date exerciseDate = new Date(13, Month.July, 2022);
DayCounter dc = new Actual365Fixed();
Exercise exercise = new EuropeanExercise(exerciseDate);
Handle <Quote> s0 = new Handle <Quote>(new SimpleQuote(100.0));
double r = 0.02;
double q = 0.00;
double v0 = 0.05;
double theta = 0.05;
double kappa_v = 0.3;
double[] sigma_v = { 0.3, 0.6 };
double rho_sv = -0.30;
double rho_sr = 0.6;
double kappa_r = 0.01;
double sigma_r = 0.01;
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(Utilities.flatRate(today, r, dc));
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(Utilities.flatRate(today, q, dc));
Handle <BlackVolTermStructure> flatVolTS = new Handle <BlackVolTermStructure>(Utilities.flatVol(today, 0.20, dc));
GeneralizedBlackScholesProcess bsProcess = new GeneralizedBlackScholesProcess(s0, qTS, rTS, flatVolTS);
HullWhiteProcess hwProcess = new HullWhiteProcess(rTS, kappa_r, sigma_r);
HullWhite hullWhiteModel = new HullWhite(new Handle <YieldTermStructure>(rTS), kappa_r, sigma_r);
double tol = 0.0001;
double[] strikes = { 40, 80, 100, 120, 180 };
double[][] expected =
{
new double[] { 0.267503, 0.235742, 0.228223, 0.223461, 0.217855 },
new double[] { 0.263626, 0.211625, 0.199907, 0.193502, 0.190025 }
};
for (int j = 0; j < sigma_v.Length; ++j)
{
HestonProcess hestonProcess = new HestonProcess(rTS, qTS, s0, v0, kappa_v, theta, sigma_v[j], rho_sv);
HestonModel hestonModel = new HestonModel(hestonProcess);
for (int i = 0; i < strikes.Length; ++i)
{
StrikedTypePayoff payoff = new PlainVanillaPayoff(Option.Type.Call, strikes[i]);
VanillaOption option = new VanillaOption(payoff, exercise);
IPricingEngine analyticH1HWEngine = new AnalyticH1HWEngine(hestonModel, hullWhiteModel, rho_sr, 144);
option.setPricingEngine(analyticH1HWEngine);
double impliedH1HW = option.impliedVolatility(option.NPV(), bsProcess);
if (Math.Abs(expected[j][i] - impliedH1HW) > tol)
{
QAssert.Fail("Failed to reproduce H1HW implied volatility"
+ "\n expected : " + expected[j][i]
+ "\n calculated : " + impliedH1HW
+ "\n tol : " + tol
+ "\n strike : " + strikes[i]
+ "\n sigma : " + sigma_v[j]);
}
}
}
}
public void testDiscretizationError()
{
// Testing the discretization error of the Heston Hull-White process
DayCounter dc = new Actual360();
Date today = Date.Today;
Settings.Instance.setEvaluationDate(today);
// construct a strange yield curve to check drifts and discounting
// of the joint stochastic process
List <Date> dates = new List <Date>();
List <double> times = new List <double>();
List <double> rates = new List <double>(), divRates = new List <double>();
for (int i = 0; i <= 31; ++i)
{
dates.Add(today + new Period(i, TimeUnit.Years));
// FLOATING_POINT_EXCEPTION
rates.Add(0.04 + 0.0001 * Math.Exp(Math.Sin(i)));
divRates.Add(0.04 + 0.0001 * Math.Exp(Math.Sin(i)));
times.Add(dc.yearFraction(today, dates.Last()));
}
Date maturity = today + new Period(10, TimeUnit.Years);
double v = 0.25;
Handle <Quote> s0 = new Handle <Quote>(new SimpleQuote(100));
SimpleQuote vol = new SimpleQuote(v);
Handle <BlackVolTermStructure> volTS = new Handle <BlackVolTermStructure>(Utilities.flatVol(today, vol, dc));
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(new InterpolatedZeroCurve <Linear>(dates, rates, dc));
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(new InterpolatedZeroCurve <Linear>(dates, divRates, dc));
BlackScholesMertonProcess bsmProcess = new BlackScholesMertonProcess(s0, qTS, rTS, volTS);
HestonProcess hestonProcess = new HestonProcess(rTS, qTS, s0, v * v, 1, v * v, 1e-6, -0.4);
HullWhiteForwardProcess hwProcess = new HullWhiteForwardProcess(rTS, 0.01, 0.01);
hwProcess.setForwardMeasureTime(20.1472222222222222);
double tol = 0.05;
double[] corr = { -0.85, 0.5 };
double[] strike = { 50, 100, 125 };
for (int i = 0; i < corr.Length; ++i)
{
for (int j = 0; j < strike.Length; ++j)
{
StrikedTypePayoff payoff = new PlainVanillaPayoff(Option.Type.Put, strike[j]);
Exercise exercise = new EuropeanExercise(maturity);
VanillaOption optionBsmHW = new VanillaOption(payoff, exercise);
HullWhite hwModel = new HullWhite(rTS, hwProcess.a(), hwProcess.sigma());
optionBsmHW.setPricingEngine(new AnalyticBSMHullWhiteEngine(corr[i], bsmProcess, hwModel));
double expected = optionBsmHW.NPV();
VanillaOption optionHestonHW = new VanillaOption(payoff, exercise);
HybridHestonHullWhiteProcess jointProcess = new HybridHestonHullWhiteProcess(hestonProcess,
hwProcess, corr[i]);
optionHestonHW.setPricingEngine(
new MakeMCHestonHullWhiteEngine <PseudoRandom, Statistics>(jointProcess)
.withSteps(1)
.withAntitheticVariate()
.withAbsoluteTolerance(tol)
.withSeed(42).getAsPricingEngine());
double calculated = optionHestonHW.NPV();
double error = optionHestonHW.errorEstimate();
if ((Math.Abs(calculated - expected) > 3 * error &&
Math.Abs(calculated - expected) > 1e-5))
{
QAssert.Fail("Failed to reproduce discretization error"
+ "\n corr: " + corr[i]
+ "\n strike: " + strike[j]
+ "\n calculated: " + calculated
+ "\n error: " + error
+ "\n expected: " + expected);
}
}
}
}
public void testCachedHullWhite()
{
//("Testing Hull-White calibration against cached values...");
Date today = new Date(15, Month.February, 2002);
Date settlement = new Date(19, Month.February, 2002);
Settings.setEvaluationDate(today);
Handle <YieldTermStructure> termStructure =
new Handle <YieldTermStructure>(Utilities.flatRate(settlement, 0.04875825, new Actual365Fixed()));
//termStructure.link
HullWhite model = new HullWhite(termStructure);
CalibrationData[] data = { new CalibrationData(1, 5, 0.1148),
new CalibrationData(2, 4, 0.1108),
new CalibrationData(3, 3, 0.1070),
new CalibrationData(4, 2, 0.1021),
new CalibrationData(5, 1, 0.1000) };
IborIndex index = new Euribor6M(termStructure);
IPricingEngine engine = new JamshidianSwaptionEngine(model);
List <CalibrationHelper> swaptions = new List <CalibrationHelper>();
for (int i = 0; i < data.Length; i++)
{
Quote vol = new SimpleQuote(data[i].volatility);
CalibrationHelper helper =
new SwaptionHelper(new Period(data[i].start, TimeUnit.Years),
new Period(data[i].length, TimeUnit.Years),
new Handle <Quote>(vol),
index,
new Period(1, TimeUnit.Years),
new Thirty360(),
new Actual360(),
termStructure,
false);
helper.setPricingEngine(engine);
swaptions.Add(helper);
}
// Set up the optimization problem
// Real simplexLambda = 0.1;
// Simplex optimizationMethod(simplexLambda);
LevenbergMarquardt optimizationMethod = new LevenbergMarquardt(1.0e-8, 1.0e-8, 1.0e-8);
EndCriteria endCriteria = new EndCriteria(10000, 100, 1e-6, 1e-8, 1e-8);
//Optimize
model.calibrate(swaptions, optimizationMethod, endCriteria, new Constraint(), new List <double>());
EndCriteria.Type ecType = model.endCriteria();
// Check and print out results
#if QL_USE_INDEXED_COUPON
double cachedA = 0.0488199, cachedSigma = 0.00593579;
#else
double cachedA = 0.0488565, cachedSigma = 0.00593662;
#endif
double tolerance = 1.120e-5;
//double tolerance = 1.0e-6;
Vector xMinCalculated = model.parameters();
double yMinCalculated = model.value(xMinCalculated, swaptions);
Vector xMinExpected = new Vector(2);
xMinExpected[0] = cachedA;
xMinExpected[1] = cachedSigma;
double yMinExpected = model.value(xMinExpected, swaptions);
if (Math.Abs(xMinCalculated[0] - cachedA) > tolerance ||
Math.Abs(xMinCalculated[1] - cachedSigma) > tolerance)
{
Assert.Fail("Failed to reproduce cached calibration results:\n"
+ "calculated: a = " + xMinCalculated[0] + ", "
+ "sigma = " + xMinCalculated[1] + ", "
+ "f(a) = " + yMinCalculated + ",\n"
+ "expected: a = " + xMinExpected[0] + ", "
+ "sigma = " + xMinExpected[1] + ", "
+ "f(a) = " + yMinExpected + ",\n"
+ "difference: a = " + (xMinCalculated[0] - xMinExpected[0]) + ", "
+ "sigma = " + (xMinCalculated[1] - xMinExpected[1]) + ", "
+ "f(a) = " + (yMinCalculated - yMinExpected) + ",\n"
+ "end criteria = " + ecType);
}
}
public void testZeroBondPricing()
{
// Testing Monte-Carlo zero bond pricing
DayCounter dc = new Actual360();
Date today = Date.Today;
Settings.Instance.setEvaluationDate(today);
// construct a strange yield curve to check drifts and discounting
// of the joint stochastic process
List <Date> dates = new List <Date>();
List <double> times = new List <double>();
List <double> rates = new List <double>();
dates.Add(today);
rates.Add(0.02);
times.Add(0.0);
for (int i = 120; i < 240; ++i)
{
dates.Add(today + new Period(i, TimeUnit.Months));
rates.Add(0.02 + 0.0002 * Math.Exp(Math.Sin(i / 8.0)));
times.Add(dc.yearFraction(today, dates.Last()));
}
Date maturity = dates.Last() + new Period(10, TimeUnit.Years);
dates.Add(maturity);
rates.Add(0.04);
//times.Add(dc.yearFraction(today, dates.Last()));
Handle <Quote> s0 = new Handle <Quote>(new SimpleQuote(100));
Handle <YieldTermStructure> ts = new Handle <YieldTermStructure>(new InterpolatedZeroCurve <Linear>(dates, rates, dc));
Handle <YieldTermStructure> ds = new Handle <YieldTermStructure>(Utilities.flatRate(today, 0.0, dc));
HestonProcess hestonProcess = new HestonProcess(ts, ds, s0, 0.02, 1.0, 0.2, 0.5, -0.8);
HullWhiteForwardProcess hwProcess = new HullWhiteForwardProcess(ts, 0.05, 0.05);
hwProcess.setForwardMeasureTime(dc.yearFraction(today, maturity));
HullWhite hwModel = new HullWhite(ts, 0.05, 0.05);
HybridHestonHullWhiteProcess jointProcess = new HybridHestonHullWhiteProcess(hestonProcess, hwProcess, -0.4);
TimeGrid grid = new TimeGrid(times);
int factors = jointProcess.factors();
int steps = grid.size() - 1;
SobolBrownianBridgeRsg rsg = new SobolBrownianBridgeRsg(factors, steps);
MultiPathGenerator <SobolBrownianBridgeRsg> generator = new MultiPathGenerator <SobolBrownianBridgeRsg>(
jointProcess, grid, rsg, false);
int m = 90;
List <GeneralStatistics> zeroStat = new InitializedList <GeneralStatistics>(m);
List <GeneralStatistics> optionStat = new InitializedList <GeneralStatistics>(m);
int nrTrails = 8191;
int optionTenor = 24;
double strike = 0.5;
for (int i = 0; i < nrTrails; ++i)
{
Sample <IPath> path = generator.next();
MultiPath value = path.value as MultiPath;
Utils.QL_REQUIRE(value != null, () => "Invalid Path");
for (int j = 1; j < m; ++j)
{
double t = grid[j]; // zero end and option maturity
double T = grid[j + optionTenor]; // maturity of zero bond
// of option
Vector states = new Vector(3);
Vector optionStates = new Vector(3);
for (int k = 0; k < jointProcess.size(); ++k)
{
states[k] = value[k][j];
optionStates[k] = value[k][j + optionTenor];
}
double zeroBond
= 1.0 / jointProcess.numeraire(t, states);
double zeroOption = zeroBond * Math.Max(0.0, hwModel.discountBond(t, T, states[2]) - strike);
zeroStat[j].add(zeroBond);
optionStat[j].add(zeroOption);
}
}
for (int j = 1; j < m; ++j)
{
double t = grid[j];
double calculated = zeroStat[j].mean();
double expected = ts.link.discount(t);
if (Math.Abs(calculated - expected) > 0.03)
{
QAssert.Fail("Failed to reproduce expected zero bond prices"
+ "\n t: " + t
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
}
double T = grid[j + optionTenor];
calculated = optionStat[j].mean();
expected = hwModel.discountBondOption(Option.Type.Call, strike, t, T);
if (Math.Abs(calculated - expected) > 0.0035)
{
QAssert.Fail("Failed to reproduce expected zero bond option prices"
+ "\n t: " + t
+ "\n T: " + T
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
}
}
}
public void testCompareBsmHWandHestonHW()
{
// Comparing European option pricing for a BSM process with one-factor Hull-White model
DayCounter dc = new Actual365Fixed();
Date today = Date.Today;
Settings.Instance.setEvaluationDate(today);
Handle <Quote> spot = new Handle <Quote>(new SimpleQuote(100.0));
List <Date> dates = new List <Date>();
List <double> rates = new List <double>(), divRates = new List <double>();
for (int i = 0; i <= 40; ++i)
{
dates.Add(today + new Period(i, TimeUnit.Years));
// FLOATING_POINT_EXCEPTION
rates.Add(0.01 + 0.0002 * Math.Exp(Math.Sin(i / 4.0)));
divRates.Add(0.02 + 0.0001 * Math.Exp(Math.Sin(i / 5.0)));
}
Handle <Quote> s0 = new Handle <Quote>(new SimpleQuote(100));
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(
new InterpolatedZeroCurve <Linear>(dates, rates, dc));
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(
new InterpolatedZeroCurve <Linear>(dates, divRates, dc));
SimpleQuote vol = new SimpleQuote(0.25);
Handle <BlackVolTermStructure> volTS = new Handle <BlackVolTermStructure>(Utilities.flatVol(today, vol, dc));
BlackScholesMertonProcess bsmProcess = new BlackScholesMertonProcess(spot, qTS, rTS, volTS);
HestonProcess hestonProcess = new HestonProcess(rTS, qTS, spot,
vol.value() * vol.value(), 1.0, vol.value() * vol.value(), 1e-4, 0.0);
HestonModel hestonModel = new HestonModel(hestonProcess);
HullWhite hullWhiteModel = new HullWhite(new Handle <YieldTermStructure>(rTS), 0.01, 0.01);
IPricingEngine bsmhwEngine = new AnalyticBSMHullWhiteEngine(0.0, bsmProcess, hullWhiteModel);
IPricingEngine hestonHwEngine = new AnalyticHestonHullWhiteEngine(hestonModel, hullWhiteModel, 128);
double tol = 1e-5;
double[] strike = { 0.25, 0.5, 0.75, 0.8, 0.9, 1.0, 1.1, 1.2, 1.5, 2.0, 4.0 };
int[] maturity = { 1, 2, 3, 5, 10, 15, 20, 25, 30 };
Option.Type[] types = { Option.Type.Put, Option.Type.Call };
for (int i = 0; i < types.Length; ++i)
{
for (int j = 0; j < strike.Length; ++j)
{
for (int l = 0; l < maturity.Length; ++l)
{
Date maturityDate = today + new Period(maturity[l], TimeUnit.Years);
Exercise exercise = new EuropeanExercise(maturityDate);
double fwd = strike[j] * spot.link.value()
* qTS.link.discount(maturityDate) / rTS.link.discount(maturityDate);
StrikedTypePayoff payoff = new PlainVanillaPayoff(types[i], fwd);
EuropeanOption option = new EuropeanOption(payoff, exercise);
option.setPricingEngine(bsmhwEngine);
double calculated = option.NPV();
option.setPricingEngine(hestonHwEngine);
double expected = option.NPV();
if (Math.Abs(calculated - expected) > calculated * tol &&
Math.Abs(calculated - expected) > tol)
{
QAssert.Fail("Failed to reproduce npvs"
+ "\n calculated: " + calculated
+ "\n expected : " + expected
+ "\n strike : " + strike[j]
+ "\n maturity : " + maturity[l]
+ "\n type : "
+ ((types[i] == QLCore.Option.Type.Put) ? "Put" : "Call"));
}
}
}
}
}
static void Main(string[] args)
{
// boost::timer timer;
Date today = new Date(16, Month.October, 2007);
Settings.setEvaluationDate(today);
Console.WriteLine();
Console.WriteLine("Pricing a callable fixed rate bond using");
Console.WriteLine("Hull White model w/ reversion parameter = 0.03");
Console.WriteLine("BAC4.65 09/15/12 ISIN: US06060WBJ36");
Console.WriteLine("roughly five year tenor, quarterly coupon and call dates");
Console.WriteLine("reference date is : " + today.ToLongDateString());
Console.WriteLine("");
/* Bloomberg OAS1: "N" model (Hull White)
* varying volatility parameter
*
* The curve entered into Bloomberg OAS1 is a flat curve,
* at constant yield = 5.5%, semiannual compounding.
* Assume here OAS1 curve uses an ACT/ACT day counter,
* as documented in PFC1 as a "default" in the latter case.
*/
// set up a flat curve corresponding to Bloomberg flat curve
double bbCurveRate = 0.055;
DayCounter bbDayCounter = new ActualActual(ActualActual.Convention.Bond);
InterestRate bbIR = new InterestRate(bbCurveRate, bbDayCounter, Compounding.Compounded, Frequency.Semiannual);
Handle <YieldTermStructure> termStructure = new Handle <YieldTermStructure>(flatRate(today,
bbIR.rate(),
bbIR.dayCounter(),
bbIR.compounding(),
bbIR.frequency()));
// set up the call schedule
CallabilitySchedule callSchedule = new CallabilitySchedule();
double callPrice = 100.0;
int numberOfCallDates = 24;
Date callDate = new Date(15, Month.September, 2006);
for (int i = 0; i < numberOfCallDates; i++)
{
Calendar nullCalendar = new NullCalendar();
Callability.Price myPrice = new Callability.Price(callPrice, Callability.Price.Type.Clean);
callSchedule.Add(new Callability(myPrice, Callability.Type.Call, callDate));
callDate = nullCalendar.advance(callDate, 3, TimeUnit.Months);
}
// set up the callable bond
Date dated = new Date(16, Month.September, 2004);
Date issue = dated;
Date maturity = new Date(15, Month.September, 2012);
int settlementDays = 3; // Bloomberg OAS1 settle is Oct 19, 2007
Calendar bondCalendar = new UnitedStates(UnitedStates.Market.GovernmentBond);
double coupon = .0465;
Frequency frequency = Frequency.Quarterly;
double redemption = 100.0;
double faceAmount = 100.0;
/* The 30/360 day counter Bloomberg uses for this bond cannot
* reproduce the US Bond/ISMA (constant) cashflows used in PFC1.
* Therefore use ActAct(Bond)
*/
DayCounter bondDayCounter = new ActualActual(ActualActual.Convention.Bond);
// PFC1 shows no indication dates are being adjusted
// for weekends/holidays for vanilla bonds
BusinessDayConvention accrualConvention = BusinessDayConvention.Unadjusted;
BusinessDayConvention paymentConvention = BusinessDayConvention.Unadjusted;
Schedule sch = new Schedule(dated, maturity, new Period(frequency), bondCalendar,
accrualConvention, accrualConvention,
DateGeneration.Rule.Backward, false);
int maxIterations = 1000;
double accuracy = 1e-8;
int gridIntervals = 40;
double reversionParameter = .03;
// output price/yield results for varying volatility parameter
double sigma = Const.QL_EPSILON; // core dumps if zero on Cygwin
ShortRateModel hw0 = new HullWhite(termStructure, reversionParameter, sigma);
IPricingEngine engine0 = new TreeCallableFixedRateBondEngine(hw0, gridIntervals, termStructure);
CallableFixedRateBond callableBond = new CallableFixedRateBond(settlementDays, faceAmount, sch,
new InitializedList <double>(1, coupon),
bondDayCounter, paymentConvention,
redemption, issue, callSchedule);
callableBond.setPricingEngine(engine0);
Console.WriteLine("sigma/vol (%) = {0:0.00}", (100.0 * sigma));
Console.WriteLine("QLNet price/yld (%) {0:0.00} / {1:0.00} ",
callableBond.cleanPrice(),
100.0 * callableBond.yield(bondDayCounter,
Compounding.Compounded,
frequency,
accuracy,
maxIterations));
Console.WriteLine("Bloomberg price/yld (%) 96,50 / 5,47");
Console.WriteLine("");
//
sigma = .01;
Console.WriteLine("sigma/vol (%) = {0:0.00}", (100.0 * sigma));
ShortRateModel hw1 = new HullWhite(termStructure, reversionParameter, sigma);
IPricingEngine engine1 = new TreeCallableFixedRateBondEngine(hw1, gridIntervals, termStructure);
callableBond.setPricingEngine(engine1);
Console.WriteLine("QLNet price/yld (%) {0:0.00} / {1:0.00} ",
callableBond.cleanPrice(),
100.0 * callableBond.yield(bondDayCounter,
Compounding.Compounded,
frequency,
accuracy,
maxIterations));
Console.WriteLine("Bloomberg price/yld (%) 95,68 / 5,66");
Console.WriteLine("");
//
sigma = .03;
Console.WriteLine("sigma/vol (%) = {0:0.00}", (100.0 * sigma));
ShortRateModel hw2 = new HullWhite(termStructure, reversionParameter, sigma);
IPricingEngine engine2 = new TreeCallableFixedRateBondEngine(hw2, gridIntervals, termStructure);
callableBond.setPricingEngine(engine2);
Console.WriteLine("QLNet price/yld (%) {0:0.00} / {1:0.00} ",
callableBond.cleanPrice(),
100.0 * callableBond.yield(bondDayCounter,
Compounding.Compounded,
frequency,
accuracy,
maxIterations));
Console.WriteLine("Bloomberg price/yld (%) 92,34 / 6,49");
Console.WriteLine("");
//
sigma = .06;
Console.WriteLine("sigma/vol (%) = {0:0.00}", (100.0 * sigma));
ShortRateModel hw3 = new HullWhite(termStructure, reversionParameter, sigma);
IPricingEngine engine3 = new TreeCallableFixedRateBondEngine(hw3, gridIntervals, termStructure);
callableBond.setPricingEngine(engine3);
Console.WriteLine("QLNet price/yld (%) {0:0.00} / {1:0.00} ",
callableBond.cleanPrice(),
100.0 * callableBond.yield(bondDayCounter,
Compounding.Compounded,
frequency,
accuracy,
maxIterations));
Console.WriteLine("Bloomberg price/yld (%) 87,16 / 7,83");
Console.WriteLine("");
//
sigma = .12;
Console.WriteLine("sigma/vol (%) = {0:0.00}", (100.0 * sigma));
ShortRateModel hw4 = new HullWhite(termStructure, reversionParameter, sigma);
IPricingEngine engine4 = new TreeCallableFixedRateBondEngine(hw4, gridIntervals, termStructure);
callableBond.setPricingEngine(engine4);
Console.WriteLine("QLNet price/yld (%) {0:0.00} / {1:0.00} ",
callableBond.cleanPrice(),
100.0 * callableBond.yield(bondDayCounter,
Compounding.Compounded,
frequency,
accuracy,
maxIterations));
Console.WriteLine("Bloomberg price/yld (%) 77,31 / 10,65");
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HullWhite obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
static void Main(string[] args)
{
DateTime timer = DateTime.Now;
Date todaysDate = new Date(15, 2, 2002);
Calendar calendar = new TARGET();
Date settlementDate = new Date(19, 2, 2002);
Settings.setEvaluationDate(todaysDate);
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
Handle <YieldTermStructure> rhTermStructure = new Handle <YieldTermStructure>(
new FlatForward(settlementDate, new Handle <Quote>(flatRate),
new Actual365Fixed()));
// Define the ATM/OTM/ITM swaps
Frequency fixedLegFrequency = Frequency.Annual;
BusinessDayConvention fixedLegConvention = BusinessDayConvention.Unadjusted;
BusinessDayConvention floatingLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.European);
Frequency floatingLegFrequency = Frequency.Semiannual;
VanillaSwap.Type type = VanillaSwap.Type.Payer;
double dummyFixedRate = 0.03;
IborIndex indexSixMonths = new Euribor6M(rhTermStructure);
Date startDate = calendar.advance(settlementDate, 1, TimeUnit.Years,
floatingLegConvention);
Date maturity = calendar.advance(startDate, 5, TimeUnit.Years,
floatingLegConvention);
Schedule fixedSchedule = new Schedule(startDate, maturity, new Period(fixedLegFrequency),
calendar, fixedLegConvention, fixedLegConvention,
DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(startDate, maturity, new Period(floatingLegFrequency),
calendar, floatingLegConvention, floatingLegConvention,
DateGeneration.Rule.Forward, false);
VanillaSwap swap = new VanillaSwap(
type, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
swap.setPricingEngine(new DiscountingSwapEngine(rhTermStructure));
double fixedAtmRate = swap.fairRate();
double fixedOtmRate = fixedAtmRate * 1.2;
double fixedItmRate = fixedAtmRate * 0.8;
VanillaSwap atmSwap = new VanillaSwap(
type, 1000.0,
fixedSchedule, fixedAtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap otmSwap = new VanillaSwap(
type, 1000.0,
fixedSchedule, fixedOtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap itmSwap = new VanillaSwap(
type, 1000.0,
fixedSchedule, fixedItmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
// defining the swaptions to be used in model calibration
List <Period> swaptionMaturities = new List <Period>(5);
swaptionMaturities.Add(new Period(1, TimeUnit.Years));
swaptionMaturities.Add(new Period(2, TimeUnit.Years));
swaptionMaturities.Add(new Period(3, TimeUnit.Years));
swaptionMaturities.Add(new Period(4, TimeUnit.Years));
swaptionMaturities.Add(new Period(5, TimeUnit.Years));
List <CalibrationHelper> swaptions = new List <CalibrationHelper>();
// List of times that have to be included in the timegrid
List <double> times = new List <double>();
for (int i = 0; i < NumRows; i++)
{
int j = NumCols - i - 1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i * NumCols + j;
Quote vol = new SimpleQuote(SwaptionVols[k]);
swaptions.Add(new SwaptionHelper(swaptionMaturities[i],
new Period(SwapLenghts[j], TimeUnit.Years),
new Handle <Quote>(vol),
indexSixMonths,
indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure, false));
swaptions.Last().addTimesTo(times);
}
// Building time-grid
TimeGrid grid = new TimeGrid(times, 30);
// defining the models
G2 modelG2 = new G2(rhTermStructure);
HullWhite modelHw = new HullWhite(rhTermStructure);
HullWhite modelHw2 = new HullWhite(rhTermStructure);
BlackKarasinski modelBk = new BlackKarasinski(rhTermStructure);
// model calibrations
Console.WriteLine("G2 (analytic formulae) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
swaptions[i].setPricingEngine(new G2SwaptionEngine(modelG2, 6.0, 16));
}
CalibrateModel(modelG2, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.0000000}\n" +
"b = {2:0.000000}, " +
"eta = {3:0.0000000}\n" +
"rho = {4:0.00000}\n",
modelG2.parameters()[0],
modelG2.parameters()[1],
modelG2.parameters()[2],
modelG2.parameters()[3],
modelG2.parameters()[4]);
Console.WriteLine("Hull-White (analytic formulae) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
swaptions[i].setPricingEngine(new JamshidianSwaptionEngine(modelHw));
}
CalibrateModel(modelHw, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.0000000}\n",
modelHw.parameters()[0],
modelHw.parameters()[1]);
Console.WriteLine("Hull-White (numerical) calibration");
for (int i = 0; i < swaptions.Count(); i++)
{
swaptions[i].setPricingEngine(new TreeSwaptionEngine(modelHw2, grid));
}
CalibrateModel(modelHw2, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.0000000}\n",
modelHw2.parameters()[0],
modelHw2.parameters()[1]);
Console.WriteLine("Black-Karasinski (numerical) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
swaptions[i].setPricingEngine(new TreeSwaptionEngine(modelBk, grid));
}
CalibrateModel(modelBk, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.00000}\n",
modelBk.parameters()[0],
modelBk.parameters()[1]);
// ATM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption "
+ "struck at {0:0.00000 %} (ATM)",
fixedAtmRate);
List <Date> bermudanDates = new List <Date>();
List <CashFlow> leg = swap.fixedLeg();
for (int i = 0; i < leg.Count; i++)
{
Coupon coupon = (Coupon)leg[i];
bermudanDates.Add(coupon.accrualStartDate());
}
Exercise bermudanExercise = new BermudanExercise(bermudanDates);
Swaption bermudanSwaption = new Swaption(atmSwap, bermudanExercise);
// Do the pricing for each model
// G2 price the European swaption here, it should switch to bermudan
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelG2, 50));
Console.WriteLine("G2: {0:0.00}", bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: {0:0.000}", bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): {0:0.000}", bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK: {0:0.000}", bermudanSwaption.NPV());
// OTM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption "
+ "struck at {0:0.00000 %} (OTM)",
fixedOtmRate);
Swaption otmBermudanSwaption = new Swaption(otmSwap, bermudanExercise);
// Do the pricing for each model
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelG2, 50));
Console.WriteLine("G2: {0:0.0000}", otmBermudanSwaption.NPV());
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: {0:0.0000}", otmBermudanSwaption.NPV());
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): {0:0.000}", otmBermudanSwaption.NPV());
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK: {0:0.0000}", otmBermudanSwaption.NPV());
// ITM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption "
+ "struck at {0:0.00000 %} (ITM)",
fixedItmRate);
Swaption itmBermudanSwaption = new Swaption(itmSwap, bermudanExercise);
// Do the pricing for each model
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelG2, 50));
Console.WriteLine("G2: {0:0.000}", itmBermudanSwaption.NPV());
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: {0:0.000}", itmBermudanSwaption.NPV());
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): {0:0.000}", itmBermudanSwaption.NPV());
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK: {0:0.000}", itmBermudanSwaption.NPV());
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
static void Main(string[] args)
{
DateTime startTime = DateTime.Now;
Date todaysDate = new Date(15, Month.February, 2002);
Calendar calendar = new TARGET();
Date settlementDate = new Date(19, Month.February, 2002);
Settings.instance().setEvaluationDate(todaysDate);
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
FlatForward myTermStructure = new FlatForward(
settlementDate,
new QuoteHandle(flatRate),
new Actual365Fixed());
RelinkableYieldTermStructureHandle rhTermStructure =
new RelinkableYieldTermStructureHandle();
rhTermStructure.linkTo(myTermStructure);
// Define the ATM/OTM/ITM swaps
Period fixedLegTenor = new Period(1, TimeUnit.Years);
BusinessDayConvention fixedLegConvention =
BusinessDayConvention.Unadjusted;
BusinessDayConvention floatingLegConvention =
BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter =
new Thirty360(Thirty360.Convention.European);
Period floatingLegTenor = new Period(6, TimeUnit.Months);
double dummyFixedRate = 0.03;
IborIndex indexSixMonths = new Euribor6M(rhTermStructure);
Date startDate = calendar.advance(settlementDate, 1, TimeUnit.Years,
floatingLegConvention);
Date maturity = calendar.advance(startDate, 5, TimeUnit.Years,
floatingLegConvention);
Schedule fixedSchedule = new Schedule(startDate, maturity,
fixedLegTenor, calendar, fixedLegConvention, fixedLegConvention,
DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(startDate, maturity,
floatingLegTenor, calendar, floatingLegConvention,
floatingLegConvention, DateGeneration.Rule.Forward, false);
VanillaSwap swap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
DiscountingSwapEngine swapEngine =
new DiscountingSwapEngine(rhTermStructure);
swap.setPricingEngine(swapEngine);
double fixedATMRate = swap.fairRate();
double fixedOTMRate = fixedATMRate * 1.2;
double fixedITMRate = fixedATMRate * 0.8;
VanillaSwap atmSwap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedATMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap otmSwap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedOTMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap itmSwap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedITMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
atmSwap.setPricingEngine(swapEngine);
otmSwap.setPricingEngine(swapEngine);
itmSwap.setPricingEngine(swapEngine);
// defining the swaptions to be used in model calibration
PeriodVector swaptionMaturities = new PeriodVector();
swaptionMaturities.Add(new Period(1, TimeUnit.Years));
swaptionMaturities.Add(new Period(2, TimeUnit.Years));
swaptionMaturities.Add(new Period(3, TimeUnit.Years));
swaptionMaturities.Add(new Period(4, TimeUnit.Years));
swaptionMaturities.Add(new Period(5, TimeUnit.Years));
CalibrationHelperVector swaptions = new CalibrationHelperVector();
// List of times that have to be included in the timegrid
DoubleVector times = new DoubleVector();
for (int i = 0; i < numRows; i++)
{
int j = numCols - i - 1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i * numCols + j;
Quote vol = new SimpleQuote(swaptionVols[k]);
SwaptionHelper helper = new SwaptionHelper(
swaptionMaturities[i],
new Period(swapLengths[j], TimeUnit.Years),
new QuoteHandle(vol),
indexSixMonths,
indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure);
swaptions.Add(helper);
times.AddRange(helper.times());
}
// Building time-grid
TimeGrid grid = new TimeGrid(times, 30);
// defining the models
// G2 modelG2 = new G2(rhTermStructure));
HullWhite modelHW = new HullWhite(rhTermStructure);
HullWhite modelHW2 = new HullWhite(rhTermStructure);
BlackKarasinski modelBK = new BlackKarasinski(rhTermStructure);
// model calibrations
// Console.WriteLine( "G2 (analytic formulae) calibration" );
// for (int i=0; i<swaptions.Count; i++)
// NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
// new G2SwaptionEngine( modelG2, 6.0, 16 ) );
//
// calibrateModel( modelG2, swaptions, 0.05);
// Console.WriteLine( "calibrated to:" );
// Console.WriteLine( "a = " + modelG2.parameters()[0] );
// Console.WriteLine( "sigma = " + modelG2.parameters()[1] );
// Console.WriteLine( "b = " + modelG2.parameters()[2] );
// Console.WriteLine( "eta = " + modelG2.parameters()[3] );
// Console.WriteLine( "rho = " + modelG2.parameters()[4] );
Console.WriteLine("Hull-White (analytic formulae) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
new JamshidianSwaptionEngine(modelHW));
}
calibrateModel(modelHW, swaptions, 0.05);
// Console.WriteLine( "calibrated to:" );
// Console.WriteLine( "a = " + modelHW.parameters()[0] );
// Console.WriteLine( "sigma = " + modelHW.parameters()[1] );
Console.WriteLine("Hull-White (numerical) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
new TreeSwaptionEngine(modelHW2, grid));
}
calibrateModel(modelHW2, swaptions, 0.05);
// std::cout << "calibrated to:\n"
// << "a = " << modelHW2->params()[0] << ", "
// << "sigma = " << modelHW2->params()[1]
// << std::endl << std::endl;
Console.WriteLine("Black-Karasinski (numerical) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
new TreeSwaptionEngine(modelBK, grid));
}
calibrateModel(modelBK, swaptions, 0.05);
// std::cout << "calibrated to:\n"
// << "a = " << modelBK->params()[0] << ", "
// << "sigma = " << modelBK->params()[1]
// << std::endl << std::endl;
// ATM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption struck at {0} (ATM)",
fixedATMRate);
DateVector bermudanDates = new DateVector();
Schedule schedule = new Schedule(startDate, maturity,
new Period(3, TimeUnit.Months), calendar,
BusinessDayConvention.Following,
BusinessDayConvention.Following,
DateGeneration.Rule.Forward, false);
for (uint i = 0; i < schedule.size(); i++)
{
bermudanDates.Add(schedule.date(i));
}
Exercise bermudaExercise = new BermudanExercise(bermudanDates);
Swaption bermudanSwaption =
new Swaption(atmSwap, bermudaExercise);
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelHW, 50));
Console.WriteLine("HW: " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelHW2, 50));
Console.WriteLine("HW (num): " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelBK, 50));
Console.WriteLine("BK (num): " + bermudanSwaption.NPV());
DateTime endTime = DateTime.Now;
TimeSpan delta = endTime - startTime;
Console.WriteLine();
Console.WriteLine("Run completed in {0} s", delta.TotalSeconds);
Console.WriteLine();
}
public void testAnalyticHestonHullWhitePricing()
{
// Testing analytic Heston Hull-White option pricing
DayCounter dc = new Actual360();
Date today = Date.Today;
Settings.Instance.setEvaluationDate(today);
// construct a strange yield curve to check drifts and discounting
// of the joint stochastic process
List <Date> dates = new List <Date>();
List <double> times = new List <double>();
List <double> rates = new List <double>(), divRates = new List <double>();
for (int i = 0; i <= 40; ++i)
{
dates.Add(today + new Period(i, TimeUnit.Years));
// FLOATING_POINT_EXCEPTION
rates.Add(0.03 + 0.0001 * Math.Exp(Math.Sin(i / 4.0)));
divRates.Add(0.02 + 0.0002 * Math.Exp(Math.Sin(i / 3.0)));
times.Add(dc.yearFraction(today, dates.Last()));
}
Date maturity = today + new Period(5, TimeUnit.Years);
Handle <Quote> s0 = new Handle <Quote>(new SimpleQuote(100));
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(new InterpolatedZeroCurve <Linear>(dates, rates, dc));
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(new InterpolatedZeroCurve <Linear>(dates, divRates, dc));
HestonProcess hestonProcess = new HestonProcess(rTS, qTS, s0, 0.08, 1.5, 0.0625, 0.5, -0.8);
HestonModel hestonModel = new HestonModel(hestonProcess);
HullWhiteForwardProcess hwFwdProcess = new HullWhiteForwardProcess(rTS, 0.01, 0.01);
hwFwdProcess.setForwardMeasureTime(dc.yearFraction(today, maturity));
HullWhite hullWhiteModel = new HullWhite(rTS, hwFwdProcess.a(), hwFwdProcess.sigma());
double tol = 0.002;
double[] strike = { 80, 120 };
Option.Type[] types = { Option.Type.Put, Option.Type.Call };
for (int i = 0; i < types.Length; ++i)
{
for (int j = 0; j < strike.Length; ++j)
{
HybridHestonHullWhiteProcess jointProcess = new HybridHestonHullWhiteProcess(hestonProcess,
hwFwdProcess, 0.0, HybridHestonHullWhiteProcess.Discretization.Euler);
StrikedTypePayoff payoff = new PlainVanillaPayoff(types[i], strike[j]);
Exercise exercise = new EuropeanExercise(maturity);
VanillaOption optionHestonHW = new VanillaOption(payoff, exercise);
optionHestonHW.setPricingEngine(new MakeMCHestonHullWhiteEngine <PseudoRandom, Statistics>(jointProcess)
.withSteps(1)
.withAntitheticVariate()
.withControlVariate()
.withAbsoluteTolerance(tol)
.withSeed(42).getAsPricingEngine());
VanillaOption optionPureHeston = new VanillaOption(payoff, exercise);
optionPureHeston.setPricingEngine(new AnalyticHestonHullWhiteEngine(hestonModel, hullWhiteModel, 128));
double calculated = optionHestonHW.NPV();
double error = optionHestonHW.errorEstimate();
double expected = optionPureHeston.NPV();
if (Math.Abs(calculated - expected) > 3 * error &&
Math.Abs(calculated - expected) > tol)
{
QAssert.Fail("Failed to reproduce hw heston vanilla prices"
+ "\n strike: " + strike[j]
+ "\n calculated: " + calculated
+ "\n error: " + error
+ "\n expected: " + expected);
}
}
}
}
