public virtual void recovery_test_normalToBlack()
{
double lambdaT = 0.07;
double lambdaK = 0.07;
double error = 1.0e-5;
ConstantCurve shiftCurve = ConstantCurve.of("Black shift", 0.02);
DirectIborCapletFloorletVolatilityDefinition definition = DirectIborCapletFloorletVolatilityDefinition.of(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, lambdaT, lambdaK, INTERPOLATOR, shiftCurve);
ImmutableList <Period> maturities = createNormalEquivMaturities();
DoubleArray strikes = createNormalEquivStrikes();
DoubleMatrix errorMatrix = DoubleMatrix.filled(maturities.size(), strikes.size(), error);
RawOptionData data = RawOptionData.of(maturities, strikes, STRIKE, createFullNormalEquivDataMatrix(), errorMatrix, 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);
}
}
}
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);
}
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);
}
public virtual void recovery_test_normal_shift_fixedRho()
{
double shift = 0.02;
DoubleArray initial = DoubleArray.of(0.05, 0.35, 0.0, 0.9);
SabrIborCapletFloorletVolatilityCalibrationDefinition definition = SabrIborCapletFloorletVolatilityCalibrationDefinition.ofFixedRho(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, shift, ALPHA_KNOTS, BETA_RHO_KNOTS, NU_KNOTS, initial, DOUBLE_QUADRATIC, FLAT, FLAT, HAGAN);
ImmutableList <Period> maturities = createNormalEquivMaturities();
DoubleArray strikes = createNormalEquivStrikes();
DoubleMatrix volData = createFullNormalEquivDataMatrix();
DoubleMatrix error = DoubleMatrix.filled(volData.rowCount(), volData.columnCount(), 1.0e-3);
RawOptionData data = RawOptionData.of(maturities, strikes, ValueType.STRIKE, volData, error, ValueType.NORMAL_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
SabrIborCapletFloorletVolatilities resVols = (SabrIborCapletFloorletVolatilities)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_SABR.presentValue(caps[j], RATES_PROVIDER, resVols).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL * 5d);
}
}
}
//-------------------------------------------------------------------------
public SurfaceMetadata createMetadata(RawOptionData capFloorData)
{
IList <GenericVolatilitySurfacePeriodParameterMetadata> list = new List <GenericVolatilitySurfacePeriodParameterMetadata>();
ImmutableList <Period> expiries = capFloorData.Expiries;
int nExpiries = expiries.size();
DoubleArray strikes = capFloorData.Strikes;
int nStrikes = strikes.size();
for (int i = 0; i < nExpiries; ++i)
{
for (int j = 0; j < nStrikes; ++j)
{
if (Double.isFinite(capFloorData.Data.get(i, j)))
{
list.Add(GenericVolatilitySurfacePeriodParameterMetadata.of(expiries.get(i), SimpleStrike.of(strikes.get(j))));
}
}
}
SurfaceMetadata metadata;
if (capFloorData.DataType.Equals(ValueType.BLACK_VOLATILITY))
{
metadata = Surfaces.blackVolatilityByExpiryStrike(name.Name, dayCount);
}
else if (capFloorData.DataType.Equals(ValueType.NORMAL_VOLATILITY))
{
metadata = Surfaces.normalVolatilityByExpiryStrike(name.Name, dayCount);
}
else
{
throw new System.ArgumentException("Data type not supported");
}
return(metadata.withParameterMetadata(list));
}
public virtual void test_createMetadata()
{
SabrIborCapletFloorletVolatilityCalibrationDefinition @base = SabrIborCapletFloorletVolatilityCalibrationDefinition.ofFixedBeta(NAME, USD_LIBOR_3M, ACT_365F, BETA_RHO, ALPHA_KNOTS, BETA_RHO_KNOTS, NU_KNOTS, DOUBLE_QUADRATIC, FLAT, LINEAR, HAGAN);
assertEquals(@base.createMetadata(SAMPLE_BLACK), Surfaces.blackVolatilityByExpiryStrike(NAME.Name, ACT_365F));
assertEquals(@base.createMetadata(SAMPLE_NORMAL), Surfaces.normalVolatilityByExpiryStrike(NAME.Name, ACT_365F));
assertThrowsIllegalArg(() => @base.createMetadata(RawOptionData.of(EXPIRIES, STRIKES, STRIKE, DATA, ValueType.PRICE)));
}
static NormalSwaptionExpiryStrikeVolatilitiesTest()
{
IList <SwaptionSurfaceExpiryStrikeParameterMetadata> list = new List <SwaptionSurfaceExpiryStrikeParameterMetadata>();
int nData = TIME.size();
for (int i = 0; i < nData; ++i)
{
SwaptionSurfaceExpiryStrikeParameterMetadata parameterMetadata = SwaptionSurfaceExpiryStrikeParameterMetadata.of(TIME.get(i), STRIKE.get(i));
list.Add(parameterMetadata);
}
METADATA = Surfaces.normalVolatilityByExpiryStrike("GOVT1-SWAPTION-VOL", ACT_365F).withParameterMetadata(list);
}
static NormalIborCapletFloorletExpiryStrikeVolatilitiesTest()
{
IList <GenericVolatilitySurfaceYearFractionParameterMetadata> list = new List <GenericVolatilitySurfaceYearFractionParameterMetadata>();
int nData = TIME.size();
for (int i = 0; i < nData; ++i)
{
GenericVolatilitySurfaceYearFractionParameterMetadata parameterMetadata = GenericVolatilitySurfaceYearFractionParameterMetadata.of(TIME.get(i), SimpleStrike.of(STRIKE.get(i)));
list.Add(parameterMetadata);
}
METADATA = Surfaces.normalVolatilityByExpiryStrike(NAME, ACT_365F).withParameterMetadata(list);
}
//-------------------------------------------------------------------------
public SurfaceMetadata createMetadata(RawOptionData capFloorData)
{
SurfaceMetadata metadata;
if (capFloorData.DataType.Equals(BLACK_VOLATILITY))
{
metadata = Surfaces.blackVolatilityByExpiryStrike(name.Name, dayCount);
}
else if (capFloorData.DataType.Equals(NORMAL_VOLATILITY))
{
metadata = Surfaces.normalVolatilityByExpiryStrike(name.Name, dayCount);
}
else
{
throw new System.ArgumentException("Data type not supported");
}
return(metadata);
}
public virtual void test_createMetadata_normal()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition @base = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(NAME, USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, DOUBLE_QUADRATIC);
RawOptionData capData = RawOptionData.of(ImmutableList.of(Period.ofYears(1), Period.ofYears(5)), DoubleArray.of(0.005, 0.01, 0.015), ValueType.STRIKE, DoubleMatrix.copyOf(new double[][]
{
new double[] { 0.15, 0.12, 0.13 },
new double[] { 0.1, Double.NaN, 0.09 }
}), ValueType.NORMAL_VOLATILITY);
IList <GenericVolatilitySurfacePeriodParameterMetadata> list = new List <GenericVolatilitySurfacePeriodParameterMetadata>();
list.Add(GenericVolatilitySurfacePeriodParameterMetadata.of(Period.ofYears(1), SimpleStrike.of(0.005)));
list.Add(GenericVolatilitySurfacePeriodParameterMetadata.of(Period.ofYears(1), SimpleStrike.of(0.01)));
list.Add(GenericVolatilitySurfacePeriodParameterMetadata.of(Period.ofYears(1), SimpleStrike.of(0.015)));
list.Add(GenericVolatilitySurfacePeriodParameterMetadata.of(Period.ofYears(5), SimpleStrike.of(0.005)));
list.Add(GenericVolatilitySurfacePeriodParameterMetadata.of(Period.ofYears(5), SimpleStrike.of(0.015)));
SurfaceMetadata expected = Surfaces.normalVolatilityByExpiryStrike(NAME.Name, ACT_ACT_ISDA).withParameterMetadata(list);
SurfaceMetadata computed = @base.createMetadata(capData);
assertEquals(computed, expected);
}
public virtual void recovery_test_normal1()
{
SurfaceIborCapletFloorletVolatilityBootstrapDefinition definition = SurfaceIborCapletFloorletVolatilityBootstrapDefinition.of(IborCapletFloorletVolatilitiesName.of("test"), USD_LIBOR_3M, ACT_ACT_ISDA, LINEAR, DOUBLE_QUADRATIC);
DoubleArray strikes = createNormalStrikes();
RawOptionData data = RawOptionData.of(createNormalMaturities(), strikes, ValueType.STRIKE, createFullNormalDataMatrix(), ValueType.NORMAL_VOLATILITY);
IborCapletFloorletVolatilityCalibrationResult res = CALIBRATOR.calibrate(definition, CALIBRATION_TIME, data, RATES_PROVIDER);
NormalIborCapletFloorletExpiryStrikeVolatilities resVol = (NormalIborCapletFloorletExpiryStrikeVolatilities)res.Volatilities;
for (int i = 0; i < strikes.size(); ++i)
{
Pair <IList <ResolvedIborCapFloorLeg>, IList <double> > capsAndVols = getCapsNormalVols(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_NORMAL.presentValue(caps[j], RATES_PROVIDER, resVol).Amount;
assertEquals(priceOrg, priceCalib, Math.Max(priceOrg, 1d) * TOL);
}
}
assertEquals(res.ChiSquare, 0d);
assertEquals(res.ChiSquare, 0d);
assertEquals(resVol.Index, USD_LIBOR_3M);
assertEquals(resVol.Name, definition.Name);
assertEquals(resVol.ValuationDateTime, CALIBRATION_TIME);
InterpolatedNodalSurface surface = (InterpolatedNodalSurface)resVol.Surface;
for (int i = 0; i < surface.ParameterCount; ++i)
{
GenericVolatilitySurfacePeriodParameterMetadata metadata = (GenericVolatilitySurfacePeriodParameterMetadata)surface.getParameterMetadata(i);
assertEquals(metadata.Strike.Value, surface.YValues.get(i));
}
}