//-------------------------------------------------------------------------
public virtual void coverage()
{
SwaptionSurfaceExpiryTenorParameterMetadata test1 = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME_TO_EXPIRY, TENOR);
coverImmutableBean(test1);
SwaptionSurfaceExpiryTenorParameterMetadata test2 = SwaptionSurfaceExpiryTenorParameterMetadata.of(2.5d, 60d, "(2.5, 60)");
coverBeanEquals(test1, test2);
}
public virtual void test_of_noLabel()
{
SwaptionSurfaceExpiryTenorParameterMetadata test = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME_TO_EXPIRY, TENOR);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, TENOR));
assertEquals(test.Label, Pair.of(TIME_TO_EXPIRY, TENOR).ToString());
assertEquals(test.Tenor, TENOR);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
public virtual void test_of_withLabel()
{
string label = "(1.5Y, 36M)";
SwaptionSurfaceExpiryTenorParameterMetadata test = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME_TO_EXPIRY, TENOR, label);
assertEquals(test.Identifier, Pair.of(TIME_TO_EXPIRY, TENOR));
assertEquals(test.Label, label);
assertEquals(test.Tenor, TENOR);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
static BlackSwaptionExpiryTenorVolatilitiesTest()
{
IList<SwaptionSurfaceExpiryTenorParameterMetadata> list = new List<SwaptionSurfaceExpiryTenorParameterMetadata>();
int nData = TIME.size();
for (int i = 0; i < nData; ++i)
{
SwaptionSurfaceExpiryTenorParameterMetadata parameterMetadata = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME.get(i), TENOR.get(i));
list.Add(parameterMetadata);
}
METADATA = Surfaces.blackVolatilityByExpiryTenor("GOVT1-SWAPTION-VOL", ACT_365F).withParameterMetadata(list);
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
SwaptionSurfaceExpiryTenorParameterMetadata other = (SwaptionSurfaceExpiryTenorParameterMetadata)obj;
return(JodaBeanUtils.equal(yearFraction, other.yearFraction) && JodaBeanUtils.equal(tenor, other.tenor) && JodaBeanUtils.equal(label, other.label));
}
return(false);
}
public virtual void test_builder_noLabel()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends SwaptionSurfaceExpiryTenorParameterMetadata> builder = SwaptionSurfaceExpiryTenorParameterMetadata.meta().builder();
BeanBuilder <SwaptionSurfaceExpiryTenorParameterMetadata> builder = SwaptionSurfaceExpiryTenorParameterMetadata.meta().builder();
Pair <double, double> pair = Pair.of(TIME_TO_EXPIRY, TENOR);
builder.set(SwaptionSurfaceExpiryTenorParameterMetadata.meta().yearFraction(), TIME_TO_EXPIRY);
builder.set(SwaptionSurfaceExpiryTenorParameterMetadata.meta().tenor(), TENOR);
SwaptionSurfaceExpiryTenorParameterMetadata test = builder.build();
assertEquals(test.Identifier, pair);
assertEquals(test.Label, pair.ToString());
assertEquals(test.Tenor, TENOR);
assertEquals(test.YearFraction, TIME_TO_EXPIRY);
}
static SwaptionSabrRateVolatilityDataSet()
{
for (int i = 0; i < EXPIRY_NODE_USD.Length; ++i)
{
SwaptionSurfaceExpiryTenorParameterMetadata @base = SwaptionSurfaceExpiryTenorParameterMetadata.of(EXPIRY_NODE_USD[i], TENOR_NODE_USD[i]);
ALPHA_PARAM_METADATA.Add(LabelParameterMetadata.of("Alpha, " + @base.Label));
BETA_PARAM_METADATA.Add(LabelParameterMetadata.of("Beta, " + @base.Label));
RHO_PARAM_METADATA.Add(LabelParameterMetadata.of("Rho, " + @base.Label));
NU_PARAM_METADATA.Add(LabelParameterMetadata.of("Nu, " + @base.Label));
}
int n = BETA_TENOR_NODE_EUR.Length;
PARAMETER_META_LIST_EUR = new List <ParameterMetadata>(n);
for (int i = 0; i < n; ++i)
{
PARAMETER_META_LIST_EUR.Add(SwaptionSurfaceExpiryTenorParameterMetadata.of(BETA_EXPIRY_NODE_EUR[i], BETA_TENOR_NODE_EUR[i]));
}
}
public virtual void test_volatility_sensitivity()
{
double eps = 1.0e-6;
int nData = TIME.size();
for (int i = 0; i < NB_TEST; i++)
{
double expiryTime = VOLS.relativeTime(TEST_OPTION_EXPIRY[i]);
SwaptionSensitivity point = SwaptionSensitivity.of(VOLS.Name, expiryTime, TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD, GBP, TEST_SENSITIVITY[i]);
CurrencyParameterSensitivities sensActual = VOLS.parameterSensitivity(point);
CurrencyParameterSensitivity sensi = sensActual.getSensitivity(SURFACE.Name, GBP);
DoubleArray computed = sensi.Sensitivity;
IDictionary <DoublesPair, double> map = new Dictionary <DoublesPair, double>();
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, TENOR, volDataUp, INTERPOLATOR_2D);
InterpolatedNodalSurface paramDw = InterpolatedNodalSurface.of(METADATA, TIME, TENOR, volDataDw, INTERPOLATOR_2D);
NormalSwaptionExpiryTenorVolatilities provUp = NormalSwaptionExpiryTenorVolatilities.of(CONVENTION, VAL_DATE_TIME, paramUp);
NormalSwaptionExpiryTenorVolatilities provDw = NormalSwaptionExpiryTenorVolatilities.of(CONVENTION, VAL_DATE_TIME, paramDw);
double volUp = provUp.volatility(TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD);
double volDw = provDw.volatility(TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD);
double fd = 0.5 * (volUp - volDw) / eps;
map[DoublesPair.of(TIME.get(j), TENOR.get(j))] = fd;
}
IList <ParameterMetadata> list = sensi.ParameterMetadata;
assertEquals(computed.size(), nData);
for (int j = 0; j < list.Count; ++j)
{
SwaptionSurfaceExpiryTenorParameterMetadata metadata = (SwaptionSurfaceExpiryTenorParameterMetadata)list[i];
double expected = map[DoublesPair.of(metadata.YearFraction, metadata.Tenor)];
assertEquals(computed.get(i), expected, eps);
}
}
}
/// <summary>
/// Check that the sensitivities of parameters with respect to data is stored in the metadata.
/// Compare the sensitivities to a finite difference approximation.
/// This test is relatively slow as it calibrates the full surface multiple times.
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void log_normal_cube_sensitivity()
public virtual void log_normal_cube_sensitivity()
{
double beta = 1.0;
Surface betaSurface = ConstantSurface.of("Beta", beta).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).zValueType(ValueType.SABR_BETA).surfaceName("Beta").build());
double shift = 0.0000;
Surface shiftSurface = ConstantSurface.of("Shift", shift).withMetadata(DefaultSurfaceMetadata.builder().xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.YEAR_FRACTION).surfaceName("Shift").build());
SabrParametersSwaptionVolatilities calibrated = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, DATA_SPARSE, MULTICURVE, betaSurface, shiftSurface);
double fdShift = 1.0E-5;
SurfaceMetadata alphaMetadata = calibrated.Parameters.AlphaSurface.Metadata;
Optional <IList <ParameterMetadata> > alphaParameterMetadataOption = alphaMetadata.ParameterMetadata;
assertTrue(alphaParameterMetadataOption.Present);
IList <ParameterMetadata> alphaParameterMetadata = alphaParameterMetadataOption.get();
IList <DoubleArray> alphaJacobian = calibrated.DataSensitivityAlpha.get();
SurfaceMetadata rhoMetadata = calibrated.Parameters.RhoSurface.Metadata;
Optional <IList <ParameterMetadata> > rhoParameterMetadataOption = rhoMetadata.ParameterMetadata;
assertTrue(rhoParameterMetadataOption.Present);
IList <ParameterMetadata> rhoParameterMetadata = rhoParameterMetadataOption.get();
IList <DoubleArray> rhoJacobian = calibrated.DataSensitivityRho.get();
SurfaceMetadata nuMetadata = calibrated.Parameters.NuSurface.Metadata;
Optional <IList <ParameterMetadata> > nuParameterMetadataOption = nuMetadata.ParameterMetadata;
assertTrue(nuParameterMetadataOption.Present);
IList <ParameterMetadata> nuParameterMetadata = nuParameterMetadataOption.get();
IList <DoubleArray> nuJacobian = calibrated.DataSensitivityNu.get();
int surfacePointIndex = 0;
for (int loopexpiry = 0; loopexpiry < EXPIRIES.Count; loopexpiry++)
{
for (int looptenor = 0; looptenor < TENORS.Count; looptenor++)
{
Tenor tenor = TENORS[looptenor];
double tenorYears = tenor.get(ChronoUnit.YEARS);
LocalDate expiry = EUR_FIXED_1Y_EURIBOR_6M.FloatingLeg.StartDateBusinessDayAdjustment.adjust(CALIBRATION_DATE.plus(EXPIRIES[loopexpiry]), REF_DATA);
ZonedDateTime expiryDateTime = expiry.atTime(11, 0).atZone(ZoneId.of("Europe/Berlin"));
double time = calibrated.relativeTime(expiryDateTime);
Pair <DoubleArray, DoubleArray> ds = DATA_SPARSE.getData(tenor).availableSmileAtExpiry(EXPIRIES[loopexpiry]);
if (!ds.First.Empty)
{
int availableDataIndex = 0;
ParameterMetadata alphaPM = alphaParameterMetadata[surfacePointIndex];
assertTrue(alphaPM is SwaptionSurfaceExpiryTenorParameterMetadata);
SwaptionSurfaceExpiryTenorParameterMetadata pmAlphaSabr = (SwaptionSurfaceExpiryTenorParameterMetadata)alphaPM;
assertEquals(tenorYears, pmAlphaSabr.Tenor);
assertEquals(time, pmAlphaSabr.YearFraction, TOLERANCE_EXPIRY);
DoubleArray alphaSensitivityToData = alphaJacobian[surfacePointIndex];
ParameterMetadata rhoPM = rhoParameterMetadata[surfacePointIndex];
assertTrue(rhoPM is SwaptionSurfaceExpiryTenorParameterMetadata);
SwaptionSurfaceExpiryTenorParameterMetadata pmRhoSabr = (SwaptionSurfaceExpiryTenorParameterMetadata)rhoPM;
assertEquals(tenorYears, pmRhoSabr.Tenor);
assertEquals(time, pmRhoSabr.YearFraction, TOLERANCE_EXPIRY);
DoubleArray rhoSensitivityToData = rhoJacobian[surfacePointIndex];
ParameterMetadata nuPM = nuParameterMetadata[surfacePointIndex];
assertTrue(nuPM is SwaptionSurfaceExpiryTenorParameterMetadata);
SwaptionSurfaceExpiryTenorParameterMetadata pmNuSabr = (SwaptionSurfaceExpiryTenorParameterMetadata)nuPM;
assertEquals(tenorYears, pmNuSabr.Tenor);
assertEquals(time, pmNuSabr.YearFraction, TOLERANCE_EXPIRY);
DoubleArray nuSensitivityToData = nuJacobian[surfacePointIndex];
for (int loopmoney = 0; loopmoney < MONEYNESS.size(); loopmoney++)
{
if (!double.IsNaN(DATA_LOGNORMAL[looptenor][loopexpiry][loopmoney]))
{
double[] alphaShifted = new double[2];
double[] rhoShifted = new double[2];
double[] nuShifted = new double[2];
for (int loopsign = 0; loopsign < 2; loopsign++)
{
TenorRawOptionData dataShifted = SabrSwaptionCalibratorSmileTestUtils.rawDataShiftPoint(TENORS, EXPIRIES, ValueType.SIMPLE_MONEYNESS, MONEYNESS, ValueType.BLACK_VOLATILITY, DATA_LOGNORMAL, looptenor, loopexpiry, loopmoney, (2 * loopsign - 1) * fdShift);
SabrParametersSwaptionVolatilities calibratedShifted = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, dataShifted, MULTICURVE, betaSurface, shiftSurface);
alphaShifted[loopsign] = calibratedShifted.Parameters.AlphaSurface.zValue(time, tenorYears);
rhoShifted[loopsign] = calibratedShifted.Parameters.RhoSurface.zValue(time, tenorYears);
nuShifted[loopsign] = calibratedShifted.Parameters.NuSurface.zValue(time, tenorYears);
}
double alphaSensitivityComputed = alphaSensitivityToData.get(availableDataIndex);
double alphaSensitivityExpected = (alphaShifted[1] - alphaShifted[0]) / (2 * fdShift);
checkAcceptable(alphaSensitivityComputed, alphaSensitivityExpected, TOLERANCE_PARAM_SENSITIVITY, "Alpha: " + looptenor + " / " + loopexpiry + " / " + loopmoney);
double rhoSensitivityComputed = rhoSensitivityToData.get(availableDataIndex);
double rhoSensitivityExpected = (rhoShifted[1] - rhoShifted[0]) / (2 * fdShift);
checkAcceptable(rhoSensitivityComputed, rhoSensitivityExpected, TOLERANCE_PARAM_SENSITIVITY, "Rho: " + looptenor + " / " + loopexpiry + " / " + loopmoney);
double nuSensitivityComputed = nuSensitivityToData.get(availableDataIndex);
double nuSensitivityExpected = (nuShifted[1] - nuShifted[0]) / (2 * fdShift);
checkAcceptable(nuSensitivityComputed, nuSensitivityExpected, TOLERANCE_PARAM_SENSITIVITY, "Nu: " + looptenor + " / " + loopexpiry + " / " + loopmoney);
availableDataIndex++;
}
}
surfacePointIndex++;
}
}
}
}
public virtual void regressionPvSurfaceSensi()
{
PointSensitivities pointComputed = SWAPTION_PRICER.presentValueSensitivityModelParamsSabr(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS_REGRESSION).build();
assertSensitivity(pointComputed, SabrParameterType.ALPHA, 6.5786313367554754E7, REGRESSION_TOL);
assertSensitivity(pointComputed, SabrParameterType.BETA, -1.2044275797229866E7, REGRESSION_TOL);
assertSensitivity(pointComputed, SabrParameterType.RHO, 266223.51118849067, REGRESSION_TOL);
assertSensitivity(pointComputed, SabrParameterType.NU, 400285.5505271345, REGRESSION_TOL);
CurrencyParameterSensitivities sensiComputed = VOLS_REGRESSION.parameterSensitivity(pointComputed);
double[][] alphaExp = new double[][]
{
new double[] { 0.0, 1.0, 0.0 },
new double[] { 0.5, 1.0, 0.0 },
new double[] { 1.0, 1.0, 0.0 },
new double[] { 2.0, 1.0, 0.0 },
new double[] { 5.0, 1.0, 0.0 },
new double[] { 10.0, 1.0, 0.0 },
new double[] { 0.0, 5.0, 0.0 },
new double[] { 0.5, 5.0, 0.0 },
new double[] { 1.0, 5.0, 6204.475194599179 },
new double[] { 2.0, 5.0, 3.94631212984123E7 },
new double[] { 5.0, 5.0, 0.0 },
new double[] { 10.0, 5.0, 0.0 },
new double[] { 0.0, 10.0, 0.0 },
new double[] { 0.5, 10.0, 0.0 },
new double[] { 1.0, 10.0, 4136.961894403858 },
new double[] { 2.0, 10.0, 2.631285063205345E7 },
new double[] { 5.0, 10.0, 0.0 },
new double[] { 10.0, 10.0, 0.0 }
};
double[][] betaExp = new double[][]
{
new double[] { 0.0, 1.0, -0.0 },
new double[] { 0.5, 1.0, -0.0 },
new double[] { 1.0, 1.0, -0.0 },
new double[] { 2.0, 1.0, -0.0 },
new double[] { 5.0, 1.0, -0.0 },
new double[] { 10.0, 1.0, -0.0 },
new double[] { 0.0, 5.0, -0.0 },
new double[] { 0.5, 5.0, -0.0 },
new double[] { 1.0, 5.0, -1135.926404680998 },
new double[] { 2.0, 5.0, -7224978.759366533 },
new double[] { 5.0, 5.0, -0.0 },
new double[] { 10.0, 5.0, -0.0 },
new double[] { 0.0, 10.0, -0.0 },
new double[] { 0.5, 10.0, -0.0 },
new double[] { 1.0, 10.0, -757.402375482629 },
new double[] { 2.0, 10.0, -4817403.70908317 },
new double[] { 5.0, 10.0, -0.0 },
new double[] { 10.0, 10.0, -0.0 }
};
double[][] rhoExp = new double[][]
{
new double[] { 0.0, 1.0, 0.0 },
new double[] { 0.5, 1.0, 0.0 },
new double[] { 1.0, 1.0, 0.0 },
new double[] { 2.0, 1.0, 0.0 },
new double[] { 5.0, 1.0, 0.0 },
new double[] { 10.0, 1.0, 0.0 },
new double[] { 0.0, 5.0, 0.0 },
new double[] { 0.5, 5.0, 0.0 },
new double[] { 1.0, 5.0, 25.10821912392996 },
new double[] { 2.0, 5.0, 159699.03429338703 },
new double[] { 5.0, 5.0, 0.0 },
new double[] { 10.0, 5.0, 0.0 },
new double[] { 0.0, 10.0, 0.0 },
new double[] { 0.5, 10.0, 0.0 },
new double[] { 1.0, 10.0, 16.741423326578513 },
new double[] { 2.0, 10.0, 106482.62725265314 },
new double[] { 5.0, 10.0, 0.0 },
new double[] { 10.0, 10.0, 0.0 }
};
double[][] nuExp = new double[][]
{
new double[] { 0.0, 1.0, 0.0 },
new double[] { 0.5, 1.0, 0.0 },
new double[] { 1.0, 1.0, 0.0 },
new double[] { 2.0, 1.0, 0.0 },
new double[] { 5.0, 1.0, 0.0 },
new double[] { 10.0, 1.0, 0.0 },
new double[] { 0.0, 5.0, 0.0 },
new double[] { 0.5, 5.0, 0.0 },
new double[] { 1.0, 5.0, 37.751952372314484 },
new double[] { 2.0, 5.0, 240118.59649585965 },
new double[] { 5.0, 5.0, 0.0 },
new double[] { 10.0, 5.0, 0.0 },
new double[] { 0.0, 10.0, 0.0 },
new double[] { 0.5, 10.0, 0.0 },
new double[] { 1.0, 10.0, 25.171893432592533 },
new double[] { 2.0, 10.0, 160104.03018547 },
new double[] { 5.0, 10.0, 0.0 },
new double[] { 10.0, 10.0, 0.0 }
};
double[][][] exps = new double[][][] { alphaExp, betaExp, rhoExp, nuExp };
SurfaceMetadata[] metadata = new SurfaceMetadata[] { SwaptionSabrRateVolatilityDataSet.META_ALPHA, SwaptionSabrRateVolatilityDataSet.META_BETA_USD, SwaptionSabrRateVolatilityDataSet.META_RHO, SwaptionSabrRateVolatilityDataSet.META_NU };
// x-y-value order does not match sorted order in surface, thus sort it
CurrencyParameterSensitivities sensiExpected = CurrencyParameterSensitivities.empty();
for (int i = 0; i < exps.Length; ++i)
{
int size = exps[i].Length;
IDictionary <DoublesPair, double> sensiMap = new SortedDictionary <DoublesPair, double>();
for (int j = 0; j < size; ++j)
{
sensiMap[DoublesPair.of(exps[i][j][0], exps[i][j][1])] = exps[i][j][2];
}
IList <ParameterMetadata> paramMetadata = new List <ParameterMetadata>(size);
IList <double> sensi = new List <double>();
foreach (KeyValuePair <DoublesPair, double> entry in sensiMap.SetOfKeyValuePairs())
{
paramMetadata.Add(SwaptionSurfaceExpiryTenorParameterMetadata.of(entry.Key.First, entry.Key.Second));
sensi.Add(entry.Value);
}
SurfaceMetadata surfaceMetadata = metadata[i].withParameterMetadata(paramMetadata);
sensiExpected = sensiExpected.combinedWith(CurrencyParameterSensitivity.of(surfaceMetadata.SurfaceName, surfaceMetadata.ParameterMetadata.get(), USD, DoubleArray.copyOf(sensi)));
}
testSurfaceParameterSensitivities(sensiComputed, sensiExpected, REGRESSION_TOL * NOTIONAL);
}
public virtual void test_serialization()
{
SwaptionSurfaceExpiryTenorParameterMetadata test = SwaptionSurfaceExpiryTenorParameterMetadata.of(TIME_TO_EXPIRY, TENOR);
assertSerialization(test);
}
