public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 3373707: // name
this.name = (IborCapletFloorletVolatilitiesName)newValue;
break;
case 100346066: // index
this.index = (IborIndex)newValue;
break;
case 1905311443: // dayCount
this.dayCount = (DayCount)newValue;
break;
case 2096253127: // interpolator
this.interpolator = (GridSurfaceInterpolator)newValue;
break;
case 1908090253: // shiftCurve
this.shiftCurve = (Curve)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 2100884654: // volatilitiesName
this.volatilitiesName = (IborCapletFloorletVolatilitiesName)newValue;
break;
case -1289159373: // expiry
this.expiry = (double?)newValue.Value;
break;
case -891985998: // strike
this.strike = (double?)newValue.Value;
break;
case -677145915: // forward
this.forward = (double?)newValue.Value;
break;
case 575402001: // currency
this.currency = (Currency)newValue;
break;
case 564403871: // sensitivity
this.sensitivity = (double?)newValue.Value;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
/// <summary>
/// Restricted copy constructor. </summary>
/// <param name="beanToCopy"> the bean to copy from, not null </param>
internal Builder(DirectIborCapletFloorletVolatilityDefinition beanToCopy)
{
this.name_Renamed = beanToCopy.Name;
this.index_Renamed = beanToCopy.Index;
this.dayCount_Renamed = beanToCopy.DayCount;
this.lambdaExpiry_Renamed = beanToCopy.LambdaExpiry;
this.lambdaStrike_Renamed = beanToCopy.LambdaStrike;
this.interpolator_Renamed = beanToCopy.Interpolator;
this.shiftCurve_Renamed = beanToCopy.shiftCurve;
}
private IborCapletFloorletSabrSensitivity(IborCapletFloorletVolatilitiesName volatilitiesName, double expiry, SabrParameterType sensitivityType, Currency currency, double sensitivity)
{
JodaBeanUtils.notNull(volatilitiesName, "volatilitiesName");
JodaBeanUtils.notNull(expiry, "expiry");
this.volatilitiesName = volatilitiesName;
this.expiry = expiry;
this.sensitivityType = sensitivityType;
this.currency = currency;
this.sensitivity = sensitivity;
}
private IborCapletFloorletSensitivity(IborCapletFloorletVolatilitiesName volatilitiesName, double expiry, double strike, double forward, Currency currency, double sensitivity)
{
JodaBeanUtils.notNull(volatilitiesName, "volatilitiesName");
JodaBeanUtils.notNull(expiry, "expiry");
JodaBeanUtils.notNull(currency, "currency");
this.volatilitiesName = volatilitiesName;
this.expiry = expiry;
this.strike = strike;
this.forward = forward;
this.currency = currency;
this.sensitivity = sensitivity;
}
private SurfaceIborCapletFloorletVolatilityBootstrapDefinition(IborCapletFloorletVolatilitiesName name, IborIndex index, DayCount dayCount, GridSurfaceInterpolator interpolator, Curve shiftCurve)
{
JodaBeanUtils.notNull(name, "name");
JodaBeanUtils.notNull(index, "index");
JodaBeanUtils.notNull(dayCount, "dayCount");
JodaBeanUtils.notNull(interpolator, "interpolator");
this.name = name;
this.index = index;
this.dayCount = dayCount;
this.interpolator = interpolator;
this.shiftCurve = shiftCurve;
validate();
}
private DirectIborCapletFloorletVolatilityDefinition(IborCapletFloorletVolatilitiesName name, IborIndex index, DayCount dayCount, double lambdaExpiry, double lambdaStrike, GridSurfaceInterpolator interpolator, Curve shiftCurve)
{
JodaBeanUtils.notNull(name, "name");
JodaBeanUtils.notNull(index, "index");
JodaBeanUtils.notNull(dayCount, "dayCount");
ArgChecker.notNegative(lambdaExpiry, "lambdaExpiry");
ArgChecker.notNegative(lambdaStrike, "lambdaStrike");
JodaBeanUtils.notNull(interpolator, "interpolator");
this.name = name;
this.index = index;
this.dayCount = dayCount;
this.lambdaExpiry = lambdaExpiry;
this.lambdaStrike = lambdaStrike;
this.interpolator = interpolator;
this.shiftCurve = shiftCurve;
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity to the SABR model parameters of the Ibor caplet/floorlet.
/// <para>
/// The sensitivity of the present value to the SABR model parameters, alpha, beta, rho and nu.
///
/// </para>
/// </summary>
/// <param name="period"> the Ibor caplet/floorlet period </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the volatilities </param>
/// <returns> the point sensitivity to the SABR model parameters </returns>
public virtual PointSensitivityBuilder presentValueSensitivityModelParamsSabr(IborCapletFloorletPeriod period, RatesProvider ratesProvider, SabrIborCapletFloorletVolatilities volatilities)
{
double expiry = volatilities.relativeTime(period.FixingDateTime);
if (expiry < 0d)
{ // option expired already
return(PointSensitivityBuilder.none());
}
Currency currency = period.Currency;
PutCall putCall = period.PutCall;
double strike = period.Strike;
double indexRate = ratesProvider.iborIndexRates(period.Index).rate(period.IborRate.Observation);
double factor = period.Notional * period.YearFraction;
ValueDerivatives volatilityAdj = volatilities.volatilityAdjoint(expiry, strike, indexRate);
DoubleArray derivative = volatilityAdj.Derivatives;
double df = ratesProvider.discountFactor(currency, period.PaymentDate);
double vega = df * factor * volatilities.priceVega(expiry, putCall, strike, indexRate, volatilityAdj.Value);
IborCapletFloorletVolatilitiesName name = volatilities.Name;
return(PointSensitivityBuilder.of(IborCapletFloorletSabrSensitivity.of(name, expiry, ALPHA, currency, vega * derivative.get(2)), IborCapletFloorletSabrSensitivity.of(name, expiry, BETA, currency, vega * derivative.get(3)), IborCapletFloorletSabrSensitivity.of(name, expiry, RHO, currency, vega * derivative.get(4)), IborCapletFloorletSabrSensitivity.of(name, expiry, NU, currency, vega * derivative.get(5))));
}
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 3373707: // name
this.name_Renamed = (IborCapletFloorletVolatilitiesName)newValue;
break;
case 100346066: // index
this.index_Renamed = (IborIndex)newValue;
break;
case 1905311443: // dayCount
this.dayCount_Renamed = (DayCount)newValue;
break;
case -1966011430: // lambdaExpiry
this.lambdaExpiry_Renamed = (double?)newValue.Value;
break;
case -1568838055: // lambdaStrike
this.lambdaStrike_Renamed = (double?)newValue.Value;
break;
case 2096253127: // interpolator
this.interpolator_Renamed = (GridSurfaceInterpolator)newValue;
break;
case 1908090253: // shiftCurve
this.shiftCurve_Renamed = (Curve)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains an instance with gird surface interpolator.
/// </summary>
/// <param name="name"> the name of the volatilities </param>
/// <param name="index"> the Ibor index </param>
/// <param name="dayCount"> the day count to use </param>
/// <param name="interpolator"> the surface interpolator </param>
/// <returns> the instance </returns>
public static SurfaceIborCapletFloorletVolatilityBootstrapDefinition of(IborCapletFloorletVolatilitiesName name, IborIndex index, DayCount dayCount, GridSurfaceInterpolator interpolator)
{
return(of(name, index, dayCount, interpolator, null));
}
public virtual void test_volatility_sensitivity()
{
double eps = 1.0e-6;
int nData = TIME.size();
for (int i = 0; i < NB_TEST; i++)
{
for (int k = 0; k < NB_TEST; k++)
{
double expiryTime = VOLS.relativeTime(TEST_OPTION_EXPIRY[i]);
IborCapletFloorletSensitivity point = IborCapletFloorletSensitivity.of(IborCapletFloorletVolatilitiesName.of(NAME), expiryTime, TEST_STRIKE[k], TEST_FORWARD, GBP, TEST_SENSITIVITY[i]);
CurrencyParameterSensitivity sensActual = VOLS.parameterSensitivity(point).Sensitivities.get(0);
DoubleArray computed = sensActual.Sensitivity;
for (int j = 0; j < nData; ++j)
{
DoubleArray volDataUp = VOL.subArray(0, nData).with(j, VOL.get(j) + eps);
DoubleArray volDataDw = VOL.subArray(0, nData).with(j, VOL.get(j) - eps);
InterpolatedNodalSurface paramUp = InterpolatedNodalSurface.of(METADATA, TIME, STRIKE, volDataUp, INTERPOLATOR_2D);
InterpolatedNodalSurface paramDw = InterpolatedNodalSurface.of(METADATA, TIME, STRIKE, volDataDw, INTERPOLATOR_2D);
NormalIborCapletFloorletExpiryStrikeVolatilities provUp = NormalIborCapletFloorletExpiryStrikeVolatilities.of(GBP_LIBOR_3M, VAL_DATE_TIME, paramUp);
NormalIborCapletFloorletExpiryStrikeVolatilities provDw = NormalIborCapletFloorletExpiryStrikeVolatilities.of(GBP_LIBOR_3M, VAL_DATE_TIME, paramDw);
double volUp = provUp.volatility(TEST_OPTION_EXPIRY[i], TEST_STRIKE[k], TEST_FORWARD);
double volDw = provDw.volatility(TEST_OPTION_EXPIRY[i], TEST_STRIKE[k], TEST_FORWARD);
double fd = 0.5 * (volUp - volDw) / eps;
assertEquals(computed.get(j), fd * TEST_SENSITIVITY[i], eps);
}
}
}
}
/// <summary>
/// Obtains an instance with shift curve.
/// </summary>
/// <param name="name"> the name of the volatilities </param>
/// <param name="index"> the Ibor index </param>
/// <param name="dayCount"> the day count to use </param>
/// <param name="lambdaExpiry"> the penalty intensity parameter for time dimension </param>
/// <param name="lambdaStrike"> the penalty intensity parameter for strike dimension </param>
/// <param name="interpolator"> the surface interpolator </param>
/// <param name="shiftCurve"> the shift surface </param>
/// <returns> the instance </returns>
public static DirectIborCapletFloorletVolatilityDefinition of(IborCapletFloorletVolatilitiesName name, IborIndex index, DayCount dayCount, double lambdaExpiry, double lambdaStrike, GridSurfaceInterpolator interpolator, Curve shiftCurve)
{
return(new DirectIborCapletFloorletVolatilityDefinition(name, index, dayCount, lambdaExpiry, lambdaStrike, interpolator, shiftCurve));
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains an instance.
/// </summary>
/// <param name="volatilitiesName"> the name of the volatilities </param>
/// <param name="expiry"> the time to expiry of the option as a year fraction </param>
/// <param name="strike"> the strike rate </param>
/// <param name="forward"> the forward rate </param>
/// <param name="sensitivityCurrency"> the currency of the sensitivity </param>
/// <param name="sensitivity"> the value of the sensitivity </param>
/// <returns> the point sensitivity object </returns>
public static IborCapletFloorletSensitivity of(IborCapletFloorletVolatilitiesName volatilitiesName, double expiry, double strike, double forward, Currency sensitivityCurrency, double sensitivity)
{
return(new IborCapletFloorletSensitivity(volatilitiesName, expiry, strike, forward, sensitivityCurrency, sensitivity));
}
public virtual void recovery_test_blackSurface_shift()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition definition = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, LINEAR, ConstantCurve.of("Black shift", 0.02));
DoubleArray strikes = createBlackStrikes();
RawOptionData data = RawOptionData.of(createBlackMaturities(), strikes, ValueType.STRIKE, createFullBlackDataMatrix(), ValueType.BLACK_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities resVol = (ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities)res.Volatilities;
for (int i = 0; i < strikes.size(); ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsBlackVols(i);
IList <ResolvedIborCapFloorLeg> caps = capsAndVols.First;
IList <double> vols = capsAndVols.Second;
int nCaps = caps.Count;
for (int j = 0; j < nCaps; ++j)
{
ConstantSurface volSurface = ConstantSurface.of(Surfaces.blackVolatilityByExpiryStrike("test", ACT_ACT_ISDA), vols[j]);
BlackIborCapletFloorletExpiryStrikeVolatilities constVol = BlackIborCapletFloorletExpiryStrikeVolatilities.of(USD_LIBOR_3M, CALIBRATION_TIME, volSurface);
double priceOrg = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, constVol).Amount;
double priceCalib = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, resVol).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL);
}
}
assertEquals(res.ChiSquare, 0d);
assertEquals(resVol.Index, USD_LIBOR_3M);
assertEquals(resVol.Name, definition.Name);
assertEquals(resVol.ValuationDateTime, CALIBRATION_TIME);
assertEquals(resVol.ShiftCurve, definition.ShiftCurve.get());
InterpolatedNodalSurface surface = (InterpolatedNodalSurface)resVol.Surface;
for (int i = 0; i < surface.ParameterCount; ++i)
{
GenericVolatilitySurfacePeriodParameterMetadata metadata = (GenericVolatilitySurfacePeriodParameterMetadata)surface.getParameterMetadata(i);
assertEquals(metadata.Strike.Value + 0.02, surface.YValues.get(i));
}
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
DirectIborCapletFloorletVolatilityDefinition test1 = DirectIborCapletFloorletVolatilityDefinition.of(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, LAMBDA_EXPIRY, LAMBDA_STRIKE, INTERPOLATOR, SHIFT_CURVE);
coverImmutableBean(test1);
DirectIborCapletFloorletVolatilityDefinition test2 = DirectIborCapletFloorletVolatilityDefinition.of(IborCapletFloorletVolatilitiesName.of("other"), GBP_LIBOR_3M, ACT_365F, 0.01, 0.02, GridSurfaceInterpolator.of(CurveInterpolators.LINEAR, CurveInterpolators.LINEAR));
coverBeanEquals(test1, test2);
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains an identifier used to find Ibor caplet/floorlet volatilities.
/// </summary>
/// <param name="name"> the name </param>
/// <returns> an identifier for the volatilities </returns>
public static IborCapletFloorletVolatilitiesId of(string name)
{
return(new IborCapletFloorletVolatilitiesId(IborCapletFloorletVolatilitiesName.of(name)));
}
/// <summary>
/// Obtains an instance with time interpolator, strike interpolator and shift curve.
/// <para>
/// The extrapolation is completed by default extrapolators in {@code GridSurfaceInterpolator}.
///
/// </para>
/// </summary>
/// <param name="name"> the name of the volatilities </param>
/// <param name="index"> the Ibor index </param>
/// <param name="dayCount"> the day count to use </param>
/// <param name="timeInterpolator"> the time interpolator </param>
/// <param name="strikeInterpolator"> the strike interpolator </param>
/// <param name="shiftCurve"> the shift curve </param>
/// <returns> the instance </returns>
public static SurfaceIborCapletFloorletVolatilityBootstrapDefinition of(IborCapletFloorletVolatilitiesName name, IborIndex index, DayCount dayCount, CurveInterpolator timeInterpolator, CurveInterpolator strikeInterpolator, Curve shiftCurve)
{
GridSurfaceInterpolator gridInterpolator = GridSurfaceInterpolator.of(timeInterpolator, strikeInterpolator);
return(of(name, index, dayCount, gridInterpolator, shiftCurve));
}
public virtual void test_recovery_black_fixedRho()
{
SabrIborCapletFloorletVolatilityBootstrapDefinition definition = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedRho(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, 0.0, CurveInterpolators.STEP_UPPER, CurveExtrapolators.FLAT, CurveExtrapolators.FLAT, SabrHaganVolatilityFunctionProvider.DEFAULT);
DoubleMatrix volData = createFullBlackDataMatrix();
double errorValue = 1.0e-3;
DoubleMatrix error = DoubleMatrix.filled(volData.rowCount(), volData.columnCount(), errorValue);
RawOptionData data = RawOptionData.of(createBlackMaturities(), createBlackStrikes(), ValueType.STRIKE, volData, error, ValueType.BLACK_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
SabrParametersIborCapletFloorletVolatilities resVols = (SabrParametersIborCapletFloorletVolatilities)res.Volatilities;
double expSq = 0d;
for (int i = 0; i < NUM_BLACK_STRIKES; ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsBlackVols(i);
IList <ResolvedIborCapFloorLeg> caps = capsAndVols.First;
IList <double> vols = capsAndVols.Second;
int nCaps = caps.Count;
for (int j = 0; j < nCaps; ++j)
{
ConstantSurface volSurface = ConstantSurface.of(Surfaces.blackVolatilityByExpiryStrike("test", ACT_ACT_ISDA), vols[j]);
BlackIborCapletFloorletExpiryStrikeVolatilities constVol = BlackIborCapletFloorletExpiryStrikeVolatilities.of(USD_LIBOR_3M, CALIBRATION_TIME, volSurface);
double priceOrg = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, constVol).Amount;
double priceCalib = LEG_PRICER_SABR.presentValue(caps[j], RATES_PROVIDER, resVols).Amount;
expSq += Math.Pow((priceOrg - priceCalib) / priceOrg / errorValue, 2);
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL * 3d);
}
}
assertEquals(res.ChiSquare, expSq, expSq * 1.0e-14);
assertEquals(resVols.Index, USD_LIBOR_3M);
assertEquals(resVols.Name, definition.Name);
assertEquals(resVols.ValuationDateTime, CALIBRATION_TIME);
assertEquals(resVols.Parameters.ShiftCurve, definition.ShiftCurve);
assertEquals(resVols.Parameters.RhoCurve, definition.RhoCurve.get());
}
public virtual void test_recovery_normal_fixedRho()
{
SabrIborCapletFloorletVolatilityBootstrapDefinition definition = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedRho(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, 0.0, CurveInterpolators.LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.FLAT, SabrHaganVolatilityFunctionProvider.DEFAULT);
RawOptionData data = RawOptionData.of(createNormalEquivMaturities(), createNormalEquivStrikes(), ValueType.STRIKE, createFullNormalEquivDataMatrix(), ValueType.NORMAL_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
SabrParametersIborCapletFloorletVolatilities resVols = (SabrParametersIborCapletFloorletVolatilities)res.Volatilities;
for (int i = 1; i < NUM_BLACK_STRIKES; ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsNormalEquivVols(i);
IList <ResolvedIborCapFloorLeg> caps = capsAndVols.First;
IList <double> vols = capsAndVols.Second;
int nCaps = caps.Count;
for (int j = 0; j < nCaps; ++j)
{
ConstantSurface volSurface = ConstantSurface.of(Surfaces.normalVolatilityByExpiryStrike("test", ACT_ACT_ISDA), vols[j]);
NormalIborCapletFloorletExpiryStrikeVolatilities constVol = NormalIborCapletFloorletExpiryStrikeVolatilities.of(USD_LIBOR_3M, CALIBRATION_TIME, volSurface);
double priceOrg = LEG_PRICER_NORMAL.presentValue(caps[j], RATES_PROVIDER, constVol).Amount;
double priceCalib = LEG_PRICER_SABR.presentValue(caps[j], RATES_PROVIDER, resVols).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL * 3d);
}
}
assertTrue(res.ChiSquare > 0d);
assertEquals(resVols.Index, USD_LIBOR_3M);
assertEquals(resVols.Name, definition.Name);
assertEquals(resVols.ValuationDateTime, CALIBRATION_TIME);
}
//-----------------------------------------------------------------------
/// <summary>
/// Sets the name of the volatilities. </summary>
/// <param name="name"> the new value, not null </param>
/// <returns> this, for chaining, not null </returns>
public Builder name(IborCapletFloorletVolatilitiesName name)
{
JodaBeanUtils.notNull(name, "name");
this.name_Renamed = name;
return(this);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
SabrIborCapletFloorletVolatilityBootstrapDefinition test1 = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedBeta(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, 0.5, LINEAR, FLAT, FLAT, SabrVolatilityFormula.hagan());
coverImmutableBean(test1);
SabrIborCapletFloorletVolatilityBootstrapDefinition test2 = SabrIborCapletFloorletVolatilityBootstrapDefinition.builder().index(GBP_LIBOR_3M).name(IborCapletFloorletVolatilitiesName.of("other")).interpolator(STEP_UPPER).extrapolatorLeft(FLAT).extrapolatorRight(CurveExtrapolators.LINEAR).rhoCurve(ConstantCurve.of("rho", 0.1d)).shiftCurve(ConstantCurve.of("shift", 0.01d)).dayCount(ACT_365F).sabrVolatilityFormula(SabrVolatilityFormula.hagan()).build();
coverBeanEquals(test1, test2);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
SabrIborCapletFloorletVolatilityCalibrationDefinition test1 = SabrIborCapletFloorletVolatilityCalibrationDefinition.ofFixedBeta(NAME, USD_LIBOR_3M, ACT_365F, BETA_RHO, ALPHA_KNOTS, BETA_RHO_KNOTS, NU_KNOTS, DOUBLE_QUADRATIC, FLAT, LINEAR, HAGAN);
coverImmutableBean(test1);
Curve betaCurve = InterpolatedNodalCurve.of(Curves.sabrParameterByExpiry(NAME.Name + "-Beta", ACT_365F, SABR_BETA), DoubleArray.of(2d, 5d), DoubleArray.of(0.5, 0.8), CurveInterpolators.PCHIP);
Curve shiftCurve = ConstantCurve.of("shift curve", 0.03d);
DoubleArray initial = DoubleArray.of(0.34, 0.5, -0.22, 1.2);
ImmutableList <DoubleArray> knots = ImmutableList.of(ALPHA_KNOTS, DoubleArray.of(), BETA_RHO_KNOTS, DoubleArray.of(1.1));
SabrIborCapletFloorletVolatilityCalibrationDefinition test2 = SabrIborCapletFloorletVolatilityCalibrationDefinition.builder().betaCurve(betaCurve).dayCount(ACT_360).extrapolatorLeft(LINEAR).extrapolatorRight(FLAT).interpolator(PCHIP).index(GBP_LIBOR_3M).initialParameters(initial).name(IborCapletFloorletVolatilitiesName.of("other")).parameterCurveNodes(knots).sabrVolatilityFormula(HAGAN).shiftCurve(shiftCurve).build();
coverBeanEquals(test1, test2);
}
public virtual void test_invalid_data()
{
SabrIborCapletFloorletVolatilityBootstrapDefinition definition = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedBeta(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, 0.85, CurveInterpolators.LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.FLAT, SabrHaganVolatilityFunctionProvider.DEFAULT);
RawOptionData data = RawOptionData.of(createBlackMaturities(), createBlackStrikes(), ValueType.STRIKE, createFullBlackDataMatrixInvalid(), ValueType.BLACK_VOLATILITY);
assertThrowsIllegalArg(() => CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition test1 = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, DOUBLE_QUADRATIC);
coverImmutableBean(test1);
SurfaceIborCapletFloorletVolatilityBootstrapDefinition test2 = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(IborCapletFloorletVolatilitiesName.of("other"), GBP_LIBOR_3M, ACT_365F, LINEAR, LINEAR, SHIFT);
coverBeanEquals(test1, test2);
}
public virtual void test_recovery_flatVol()
{
double beta = 0.8;
SabrIborCapletFloorletVolatilityBootstrapDefinition definition = SabrIborCapletFloorletVolatilityBootstrapDefinition.ofFixedBeta(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, beta, CurveInterpolators.STEP_UPPER, CurveExtrapolators.FLAT, CurveExtrapolators.FLAT, SabrHaganVolatilityFunctionProvider.DEFAULT);
RawOptionData data = RawOptionData.of(createBlackMaturities(), createBlackStrikes(), ValueType.STRIKE, createFullFlatBlackDataMatrix(), ValueType.BLACK_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
SabrParametersIborCapletFloorletVolatilities resVols = (SabrParametersIborCapletFloorletVolatilities)res.Volatilities;
for (int i = 0; i < NUM_BLACK_STRIKES; ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsFlatBlackVols(i);
IList <ResolvedIborCapFloorLeg> caps = capsAndVols.First;
IList <double> vols = capsAndVols.Second;
int nCaps = caps.Count;
for (int j = 0; j < nCaps; ++j)
{
ConstantSurface volSurface = ConstantSurface.of(Surfaces.blackVolatilityByExpiryStrike("test", ACT_ACT_ISDA), vols[j]);
BlackIborCapletFloorletExpiryStrikeVolatilities constVol = BlackIborCapletFloorletExpiryStrikeVolatilities.of(USD_LIBOR_3M, CALIBRATION_TIME, volSurface);
double priceOrg = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, constVol).Amount;
double priceCalib = LEG_PRICER_SABR.presentValue(caps[j], RATES_PROVIDER, resVols).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL);
}
}
}
public virtual void recovery_test_flat()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition definition = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, LINEAR);
DoubleArray strikes = createBlackStrikes();
RawOptionData data = RawOptionData.of(createBlackMaturities(), strikes, ValueType.STRIKE, createFullFlatBlackDataMatrix(), ValueType.BLACK_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
BlackIborCapletFloorletExpiryStrikeVolatilities resVol = (BlackIborCapletFloorletExpiryStrikeVolatilities)res.Volatilities;
for (int i = 0; i < NUM_BLACK_STRIKES; ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsFlatBlackVols(i);
IList <ResolvedIborCapFloorLeg> caps = capsAndVols.First;
IList <double> vols = capsAndVols.Second;
int nCaps = caps.Count;
for (int j = 0; j < nCaps; ++j)
{
ConstantSurface volSurface = ConstantSurface.of(Surfaces.blackVolatilityByExpiryStrike("test", ACT_ACT_ISDA), vols[j]);
BlackIborCapletFloorletExpiryStrikeVolatilities constVol = BlackIborCapletFloorletExpiryStrikeVolatilities.of(USD_LIBOR_3M, CALIBRATION_TIME, volSurface);
double priceOrg = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, constVol).Amount;
double priceCalib = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, resVol).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL);
}
}
assertEquals(res.ChiSquare, 0d);
}
private IborCapletFloorletVolatilitiesId(IborCapletFloorletVolatilitiesName name)
{
JodaBeanUtils.notNull(name, "name");
this.name = name;
}
public virtual void recovery_test_normal2_shift()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition definition = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, DOUBLE_QUADRATIC, ConstantCurve.of("Black shift", 0.02));
DoubleArray strikes = createNormalEquivStrikes();
RawOptionData data = RawOptionData.of(createNormalEquivMaturities(), strikes, ValueType.STRIKE, createFullNormalEquivDataMatrix(), ValueType.NORMAL_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities resVol = (ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities)res.Volatilities;
for (int i = 0; i < strikes.size(); ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsNormalEquivVols(i);
IList <ResolvedIborCapFloorLeg> caps = capsAndVols.First;
IList <double> vols = capsAndVols.Second;
int nCaps = caps.Count;
for (int j = 0; j < nCaps; ++j)
{
ConstantSurface volSurface = ConstantSurface.of(Surfaces.normalVolatilityByExpiryStrike("test", ACT_ACT_ISDA), vols[j]);
NormalIborCapletFloorletExpiryStrikeVolatilities constVol = NormalIborCapletFloorletExpiryStrikeVolatilities.of(USD_LIBOR_3M, CALIBRATION_TIME, volSurface);
double priceOrg = LEG_PRICER_NORMAL.presentValue(caps[j], RATES_PROVIDER, constVol).Amount;
double priceCalib = LEG_PRICER_BLACK.presentValue(caps[j], RATES_PROVIDER, resVol).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL);
}
}
assertEquals(res.ChiSquare, 0d);
}
/// <summary>
/// Obtains an identifier used to find Ibor caplet/floorlet volatilities.
/// </summary>
/// <param name="name"> the name </param>
/// <returns> an identifier for the volatilities </returns>
public static IborCapletFloorletVolatilitiesId of(IborCapletFloorletVolatilitiesName name)
{
return(new IborCapletFloorletVolatilitiesId(name));
}
public virtual void test_invalid_data()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition definition = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, LINEAR);
DoubleArray strikes = createBlackStrikes();
RawOptionData data = RawOptionData.of(createBlackMaturities(), strikes, ValueType.STRIKE, createFullBlackDataMatrixInvalid(), ValueType.BLACK_VOLATILITY);
assertThrowsIllegalArg(() => CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER));
}
