public virtual void regression_pvSensi()
{
PointSensitivityBuilder point = PRICER.presentValueSensitivityRates(CAPLET_REG, RATES, VOLS);
CurrencyParameterSensitivities sensi = RATES.parameterSensitivity(point.build());
double[] sensiDsc = new double[] { 0.0, 0.0, 0.0, -7.148360371957523, -1.8968344850148018, 0.0 }; // 2.x
double[] sensiFwd = new double[] { 0.0, 0.0, 0.0, -3999.714444844649, 5987.977558683395, 0.0, 0.0, 0.0 }; // 2.x
assertTrue(DoubleArrayMath.fuzzyEquals(sensi.getSensitivity(IborCapletFloorletDataSet.DSC_NAME, EUR).Sensitivity.toArray(), sensiDsc, NOTIONAL * TOL));
assertTrue(DoubleArrayMath.fuzzyEquals(sensi.getSensitivity(IborCapletFloorletDataSet.FWD3_NAME, EUR).Sensitivity.toArray(), sensiFwd, NOTIONAL * TOL));
}
public virtual void test_parameterSensitivity()
{
double alphaSensi = 2.24, betaSensi = 3.45, rhoSensi = -2.12, nuSensi = -0.56, shiftSensi = 2.5;
SabrParametersIborCapletFloorletVolatilities prov = SabrParametersIborCapletFloorletVolatilities.of(NAME, EUR_EURIBOR_3M, DATE_TIME, PARAM);
for (int i = 0; i < NB_TEST; i++)
{
double expiryTime = prov.relativeTime(TEST_OPTION_EXPIRY[i]);
PointSensitivities point = PointSensitivities.of(IborCapletFloorletSabrSensitivity.of(NAME, expiryTime, ALPHA, EUR, alphaSensi), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime, BETA, EUR, betaSensi), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime, RHO, EUR, rhoSensi), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime, NU, EUR, nuSensi), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime, SHIFT, EUR, shiftSensi));
CurrencyParameterSensitivities sensiComputed = prov.parameterSensitivity(point);
UnitParameterSensitivity alphaSensitivities = prov.Parameters.AlphaCurve.yValueParameterSensitivity(expiryTime);
UnitParameterSensitivity betaSensitivities = prov.Parameters.BetaCurve.yValueParameterSensitivity(expiryTime);
UnitParameterSensitivity rhoSensitivities = prov.Parameters.RhoCurve.yValueParameterSensitivity(expiryTime);
UnitParameterSensitivity nuSensitivities = prov.Parameters.NuCurve.yValueParameterSensitivity(expiryTime);
UnitParameterSensitivity shiftSensitivities = prov.Parameters.ShiftCurve.yValueParameterSensitivity(expiryTime);
CurrencyParameterSensitivity alphaSensiObj = sensiComputed.getSensitivity(IborCapletFloorletSabrRateVolatilityDataSet.META_ALPHA.CurveName, EUR);
CurrencyParameterSensitivity betaSensiObj = sensiComputed.getSensitivity(IborCapletFloorletSabrRateVolatilityDataSet.META_BETA.CurveName, EUR);
CurrencyParameterSensitivity rhoSensiObj = sensiComputed.getSensitivity(IborCapletFloorletSabrRateVolatilityDataSet.META_RHO.CurveName, EUR);
CurrencyParameterSensitivity nuSensiObj = sensiComputed.getSensitivity(IborCapletFloorletSabrRateVolatilityDataSet.META_NU.CurveName, EUR);
CurrencyParameterSensitivity shiftSensiObj = sensiComputed.getSensitivity(IborCapletFloorletSabrRateVolatilityDataSet.META_SHIFT.CurveName, EUR);
DoubleArray alphaNodeSensiComputed = alphaSensiObj.Sensitivity;
DoubleArray betaNodeSensiComputed = betaSensiObj.Sensitivity;
DoubleArray rhoNodeSensiComputed = rhoSensiObj.Sensitivity;
DoubleArray nuNodeSensiComputed = nuSensiObj.Sensitivity;
DoubleArray shiftNodeSensiComputed = shiftSensiObj.Sensitivity;
assertEquals(alphaSensitivities.Sensitivity.size(), alphaNodeSensiComputed.size());
assertEquals(betaSensitivities.Sensitivity.size(), betaNodeSensiComputed.size());
assertEquals(rhoSensitivities.Sensitivity.size(), rhoNodeSensiComputed.size());
assertEquals(nuSensitivities.Sensitivity.size(), nuNodeSensiComputed.size());
assertEquals(shiftSensitivities.Sensitivity.size(), shiftNodeSensiComputed.size());
for (int k = 0; k < alphaNodeSensiComputed.size(); ++k)
{
assertEquals(alphaNodeSensiComputed.get(k), alphaSensitivities.Sensitivity.get(k) * alphaSensi, TOLERANCE_VOL);
}
for (int k = 0; k < betaNodeSensiComputed.size(); ++k)
{
assertEquals(betaNodeSensiComputed.get(k), betaSensitivities.Sensitivity.get(k) * betaSensi, TOLERANCE_VOL);
}
for (int k = 0; k < rhoNodeSensiComputed.size(); ++k)
{
assertEquals(rhoNodeSensiComputed.get(k), rhoSensitivities.Sensitivity.get(k) * rhoSensi, TOLERANCE_VOL);
}
for (int k = 0; k < nuNodeSensiComputed.size(); ++k)
{
assertEquals(nuNodeSensiComputed.get(k), nuSensitivities.Sensitivity.get(k) * nuSensi, TOLERANCE_VOL);
}
for (int k = 0; k < shiftNodeSensiComputed.size(); ++k)
{
assertEquals(shiftNodeSensiComputed.get(k), shiftSensitivities.Sensitivity.get(k) * shiftSensi, TOLERANCE_VOL);
}
}
}
//-------------------------------------------------------------------------
// regression to 2.x
public virtual void regression()
{
CurrencyAmount pv = TRADE_PRICER.presentValue(FUTURE_TRADE, PROVIDER, TRADE_PRICE);
assertEquals(pv.Amount, 4022633.290539182, NOTIONAL * QUANTITY * TOL);
DoubleArray dscExp = DoubleArray.of(347963.1427498563, 240275.26230191416, 123908.37739051704, -1302968.1341957184, -8402797.591029292, -9024590.733895564);
DoubleArray fwdExp = DoubleArray.of(1.5288758221797276E7, 1.2510651813905597E7, -1535786.53682933, -9496881.09854053, -3.583343769759877E7, -1.1342379328462188E9);
PointSensitivities point = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE, PROVIDER);
CurrencyParameterSensitivities sensi = PROVIDER.parameterSensitivity(point);
double tolerance = NOTIONAL * QUANTITY * EPS;
assertTrue(sensi.getSensitivity(USD_DSC_NAME, USD).Sensitivity.equalWithTolerance(dscExp, tolerance));
assertTrue(sensi.getSensitivity(USD_FWD3_NAME, USD).Sensitivity.equalWithTolerance(fwdExp, tolerance));
}
public virtual void test_sensitivity_LegalEntityDiscountingProvider()
{
CurrencyParameterSensitivities computed = CALC.sensitivity(PARAMETER_SENSITIVITIES, PROVIDER);
assertEquals(computed.Sensitivities.size(), 4);
DoubleArray expected11 = (DoubleArray)MATRIX_ALGEBRA.multiply(SENSI_1, DoubleMatrix.copyOf(MATRIX_11));
DoubleArray expected12 = (DoubleArray)MATRIX_ALGEBRA.multiply(SENSI_1, DoubleMatrix.copyOf(MATRIX_12));
DoubleArray expected21 = (DoubleArray)MATRIX_ALGEBRA.multiply(SENSI_2, DoubleMatrix.copyOf(MATRIX_21));
DoubleArray expected22 = (DoubleArray)MATRIX_ALGEBRA.multiply(SENSI_2, DoubleMatrix.copyOf(MATRIX_22));
assertTrue(computed.getSensitivity(CURVE_NAME_1, USD).Sensitivity.equalWithTolerance(expected11, TOL));
assertTrue(computed.getSensitivity(CURVE_NAME_1, GBP).Sensitivity.equalWithTolerance(expected21, TOL));
assertTrue(computed.getSensitivity(CURVE_NAME_2, USD).Sensitivity.equalWithTolerance(expected12, TOL));
assertTrue(computed.getSensitivity(CURVE_NAME_2, GBP).Sensitivity.equalWithTolerance(expected22, TOL));
}
public virtual void parSpreadSensitivity()
{
// March 2016
PointSensitivities pointMar = TRADE_PRICER.parSpreadSensitivity(FUTURE_TRADE_MAR, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiMar = RATES_PROVIDER.parameterSensitivity(pointMar);
double[] sensiFwdMar = new double[] { 0.003743310260261194, -0.01313010637003998, -4.527622886220682E-4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiMar.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdMar, TOL));
// June 2016
PointSensitivities pointJun = TRADE_PRICER.parSpreadSensitivity(FUTURE_TRADE_JUN, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiJun = RATES_PROVIDER.parameterSensitivity(pointJun);
double[] sensiFwdJun = new double[] { 0.0, 0.01347165823324645, 0.0, 0.0, -0.023308107101966076, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiJun.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdJun, TOL));
// September 2016
PointSensitivities pointSep = TRADE_PRICER.parSpreadSensitivity(FUTURE_TRADE_SEP, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiSep = RATES_PROVIDER.parameterSensitivity(pointSep);
double[] sensiFwdSep = new double[] { 0.0, 0.0, 0.0, 0.0, 0.01936692513656471, 0.0048417312841411864, 0.0, -0.027462515988551, -0.006580907103066675, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiSep.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdSep, TOL));
// June 2017
PointSensitivities pointJunMid = TRADE_PRICER.parSpreadSensitivity(FUTURE_TRADE_JUN_MID, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiJunMid = RATES_PROVIDER.parameterSensitivity(pointJunMid);
double[] sensiFwdJunMid = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.016154080854008976, -0.013340017892182532, -0.012672512226590141, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiJunMid.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdJunMid, TOL));
// March 2020
PointSensitivities pointMarLong = TRADE_PRICER.parSpreadSensitivity(FUTURE_TRADE_MAR_LONG, RATES_PROVIDER).multipliedBy(HUNDRED * ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiMarLong = RATES_PROVIDER.parameterSensitivity(pointMarLong);
double[] sensiFwdMarLong = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03382389130551987, -0.043661005746776824, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiMarLong.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdMarLong, TOL));
}
public virtual void presentValueSensitivity()
{
// March 2016
PointSensitivities pointMar = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE_MAR, RATES_PROVIDER).multipliedBy(ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiMar = RATES_PROVIDER.parameterSensitivity(pointMar);
double[] sensiFwdMar = new double[] { 935.8275650652985, -3282.5265925099943, -113.19057215551703, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiMar.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdMar, TOL));
// June 2016
PointSensitivities pointJun = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE_JUN, RATES_PROVIDER).multipliedBy(ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiJun = RATES_PROVIDER.parameterSensitivity(pointJun);
double[] sensiFwdJun = new double[] { 0.0, 3367.914558311612, 0.0, 0.0, -5827.0267754915185, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiJun.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdJun, TOL));
// September 2016
PointSensitivities pointSep = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE_SEP, RATES_PROVIDER).multipliedBy(ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiSep = RATES_PROVIDER.parameterSensitivity(pointSep);
double[] sensiFwdSep = new double[] { 0.0, 0.0, 0.0, 0.0, 4841.731284141179, 1210.432821035297, 0.0, -6865.62899713775, -1645.2267757666687, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiSep.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdSep, TOL));
// June 2017
PointSensitivities pointJunMid = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE_JUN_MID, RATES_PROVIDER).multipliedBy(ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiJunMid = RATES_PROVIDER.parameterSensitivity(pointJunMid);
double[] sensiFwdJunMid = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4038.520213502244, -3335.0044730456357, -3168.128056647536, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiJunMid.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdJunMid, TOL));
// March 2020
PointSensitivities pointMarLong = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE_MAR_LONG, RATES_PROVIDER).multipliedBy(ONE_BASIS_POINT);
CurrencyParameterSensitivities sensiMarLong = RATES_PROVIDER.parameterSensitivity(pointMarLong);
double[] sensiFwdMarLong = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 8455.972826379962, -10915.251436694207, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
assertTrue(DoubleArrayMath.fuzzyEquals(sensiMarLong.getSensitivity(NAME_FWD, JPY).Sensitivity.toArray(), sensiFwdMarLong, TOL));
}
public virtual void regression_sensitivity()
{
PointSensitivities point = PRICER.priceSensitivityRates(FUTURE, RATE_PROVIDER, HW_PROVIDER);
CurrencyParameterSensitivities computed = RATE_PROVIDER.parameterSensitivity(point);
double[] expected = new double[] { 0.0, 0.0, 0.9514709785770106, -1.9399920741192112, 0.0, 0.0, 0.0, 0.0 };
assertEquals(computed.size(), 1);
assertTrue(DoubleArrayMath.fuzzyEquals(computed.getSensitivity(HullWhiteIborFutureDataSet.FWD3_NAME, EUR).Sensitivity.toArray(), expected, TOL));
}
public virtual void regression_withZSpread_periodic()
{
double price = FUTURE_PRICER.priceWithZSpread(FUTURE_PRODUCT, PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
assertEquals(price, 1.1720190529653407, TOL);
PointSensitivities point = FUTURE_PRICER.priceSensitivityWithZSpread(FUTURE_PRODUCT, PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
CurrencyParameterSensitivities test = PROVIDER.parameterSensitivity(point);
DoubleArray expectedIssuer = DoubleArray.of(-3.9201229100932256E-4, -0.0041367134351306374, -0.014173323438217467, -0.9886444827927878, -4.07533109609094, 0);
DoubleArray actualIssuer = test.getSensitivity(METADATA_ISSUER.CurveName, USD).Sensitivity;
assertTrue(actualIssuer.equalWithTolerance(expectedIssuer, TOL));
DoubleArray expectedRepo = DoubleArray.of(0.1428352116441475, 0.20242871054203687, 0.0, 0.0, 0.0, 0.0);
DoubleArray actualRepo = test.getSensitivity(METADATA_REPO.CurveName, USD).Sensitivity;
assertTrue(actualRepo.equalWithTolerance(expectedRepo, TOL));
}
//-------------------------------------------------------------------------
// regression to 2.x
public virtual void regression()
{
double price = FUTURE_PRICER.price(FUTURE_PRODUCT, PROVIDER);
assertEquals(price, 1.2106928633440506, TOL);
PointSensitivities point = FUTURE_PRICER.priceSensitivity(FUTURE_PRODUCT, PROVIDER);
CurrencyParameterSensitivities test = PROVIDER.parameterSensitivity(point);
DoubleArray expectedIssuer = DoubleArray.of(-3.940585873921608E-4, -0.004161527192990392, -0.014331606019672717, -1.0229665443857998, -4.220553063715371, 0);
DoubleArray actualIssuer = test.getSensitivity(METADATA_ISSUER.CurveName, USD).Sensitivity;
assertTrue(actualIssuer.equalWithTolerance(expectedIssuer, TOL));
DoubleArray expectedRepo = DoubleArray.of(0.14752541809405412, 0.20907575809356016, 0.0, 0.0, 0.0, 0.0);
DoubleArray actualRepo = test.getSensitivity(METADATA_REPO.CurveName, USD).Sensitivity;
assertTrue(actualRepo.equalWithTolerance(expectedRepo, TOL));
}
public virtual void regression_withZSpread_periodic()
{
CurrencyAmount pv = TRADE_PRICER.presentValueWithZSpread(FUTURE_TRADE, PROVIDER, SETTLE_PRICE, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
assertEquals(pv.Amount, -7710148.864076961, EPS * NOTIONAL * QUANTITY);
PointSensitivities pvPoint = TRADE_PRICER.presentValueSensitivityWithZSpread(FUTURE_TRADE, PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
CurrencyParameterSensitivities test = PROVIDER.parameterSensitivity(pvPoint);
DoubleArray expectedIssuer = DoubleArray.of(-48374.31671055041, -510470.43789512076, -1748988.1122760356, -1.2199872917663E8, -5.0289585725762194E8, 0);
DoubleArray actualIssuer = test.getSensitivity(METADATA_ISSUER.CurveName, USD).Sensitivity;
assertTrue(actualIssuer.equalWithTolerance(expectedIssuer, TOL * NOTIONAL * QUANTITY));
DoubleArray expectedRepo = DoubleArray.of(1.7625865116887797E7, 2.497970288088735E7, 0.0, 0.0, 0.0, 0.0);
DoubleArray actualRepo = test.getSensitivity(METADATA_REPO.CurveName, USD).Sensitivity;
assertTrue(actualRepo.equalWithTolerance(expectedRepo, TOL * NOTIONAL * QUANTITY));
}
//-------------------------------------------------------------------------
// regression to 2.x
public virtual void regression()
{
CurrencyAmount pv = TRADE_PRICER.presentValue(FUTURE_TRADE, PROVIDER, SETTLE_PRICE);
assertEquals(pv.Amount, -2937800.66334416, EPS * NOTIONAL * QUANTITY);
PointSensitivities pvPoint = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE, PROVIDER);
CurrencyParameterSensitivities test = PROVIDER.parameterSensitivity(pvPoint);
DoubleArray expectedIssuer = DoubleArray.of(-48626.82968419264, -513532.4556150143, -1768520.182827613, -1.262340715772077E8, -5.208162480624767E8, 0);
DoubleArray actualIssuer = test.getSensitivity(METADATA_ISSUER.CurveName, USD).Sensitivity;
assertTrue(actualIssuer.equalWithTolerance(expectedIssuer, TOL * NOTIONAL * QUANTITY));
DoubleArray expectedRepo = DoubleArray.of(1.8204636592806276E7, 2.5799948548745323E7, 0.0, 0.0, 0.0, 0.0);
DoubleArray actualRepo = test.getSensitivity(METADATA_REPO.CurveName, USD).Sensitivity;
assertTrue(actualRepo.equalWithTolerance(expectedRepo, TOL * NOTIONAL * QUANTITY));
}
public virtual void test_parameterSensitivity()
{
double alphaSensi = 2.24, betaSensi = 3.45, rhoSensi = -2.12, nuSensi = -0.56;
SabrParametersSwaptionVolatilities prov = SabrParametersSwaptionVolatilities.of(NAME, CONV, DATE_TIME, PARAM);
for (int i = 0; i < NB_TEST; i++)
{
double expiryTime = prov.relativeTime(TEST_OPTION_EXPIRY[i]);
PointSensitivities point = PointSensitivities.of(SwaptionSabrSensitivity.of(NAME, expiryTime, TEST_TENOR[i], ALPHA, USD, alphaSensi), SwaptionSabrSensitivity.of(NAME, expiryTime, TEST_TENOR[i], BETA, USD, betaSensi), SwaptionSabrSensitivity.of(NAME, expiryTime, TEST_TENOR[i], RHO, USD, rhoSensi), SwaptionSabrSensitivity.of(NAME, expiryTime, TEST_TENOR[i], NU, USD, nuSensi));
CurrencyParameterSensitivities sensiComputed = prov.parameterSensitivity(point);
UnitParameterSensitivity alphaSensitivities = prov.Parameters.AlphaSurface.zValueParameterSensitivity(expiryTime, TEST_TENOR[i]);
UnitParameterSensitivity betaSensitivities = prov.Parameters.BetaSurface.zValueParameterSensitivity(expiryTime, TEST_TENOR[i]);
UnitParameterSensitivity rhoSensitivities = prov.Parameters.RhoSurface.zValueParameterSensitivity(expiryTime, TEST_TENOR[i]);
UnitParameterSensitivity nuSensitivities = prov.Parameters.NuSurface.zValueParameterSensitivity(expiryTime, TEST_TENOR[i]);
CurrencyParameterSensitivity alphaSensiObj = sensiComputed.getSensitivity(SwaptionSabrRateVolatilityDataSet.META_ALPHA.SurfaceName, USD);
CurrencyParameterSensitivity betaSensiObj = sensiComputed.getSensitivity(SwaptionSabrRateVolatilityDataSet.META_BETA_USD.SurfaceName, USD);
CurrencyParameterSensitivity rhoSensiObj = sensiComputed.getSensitivity(SwaptionSabrRateVolatilityDataSet.META_RHO.SurfaceName, USD);
CurrencyParameterSensitivity nuSensiObj = sensiComputed.getSensitivity(SwaptionSabrRateVolatilityDataSet.META_NU.SurfaceName, USD);
DoubleArray alphaNodeSensiComputed = alphaSensiObj.Sensitivity;
DoubleArray betaNodeSensiComputed = betaSensiObj.Sensitivity;
DoubleArray rhoNodeSensiComputed = rhoSensiObj.Sensitivity;
DoubleArray nuNodeSensiComputed = nuSensiObj.Sensitivity;
assertEquals(alphaSensitivities.Sensitivity.size(), alphaNodeSensiComputed.size());
assertEquals(betaSensitivities.Sensitivity.size(), betaNodeSensiComputed.size());
assertEquals(rhoSensitivities.Sensitivity.size(), rhoNodeSensiComputed.size());
assertEquals(nuSensitivities.Sensitivity.size(), nuNodeSensiComputed.size());
for (int k = 0; k < alphaNodeSensiComputed.size(); ++k)
{
assertEquals(alphaNodeSensiComputed.get(k), alphaSensitivities.Sensitivity.get(k) * alphaSensi, TOLERANCE_VOL);
}
for (int k = 0; k < betaNodeSensiComputed.size(); ++k)
{
assertEquals(betaNodeSensiComputed.get(k), betaSensitivities.Sensitivity.get(k) * betaSensi, TOLERANCE_VOL);
}
for (int k = 0; k < rhoNodeSensiComputed.size(); ++k)
{
assertEquals(rhoNodeSensiComputed.get(k), rhoSensitivities.Sensitivity.get(k) * rhoSensi, TOLERANCE_VOL);
}
for (int k = 0; k < nuNodeSensiComputed.size(); ++k)
{
assertEquals(nuNodeSensiComputed.get(k), nuSensitivities.Sensitivity.get(k) * nuSensi, TOLERANCE_VOL);
}
}
}
public virtual void test_parameterSensitivity_multi()
{
double[] points1 = new double[] { 2.24, 3.45, -2.12, -0.56 };
double[] points2 = new double[] { -0.145, 1.01, -5.0, -11.0 };
double[] points3 = new double[] { 1.3, -4.32, 2.1, -7.18 };
SabrParametersSwaptionVolatilities prov = SabrParametersSwaptionVolatilities.of(NAME, CONV, DATE_TIME, PARAM);
double expiryTime0 = prov.relativeTime(TEST_OPTION_EXPIRY[0]);
double expiryTime3 = prov.relativeTime(TEST_OPTION_EXPIRY[3]);
for (int i = 0; i < NB_TEST; i++)
{
PointSensitivities sensi1 = PointSensitivities.of(SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], ALPHA, USD, points1[0]), SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], BETA, USD, points1[1]), SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], RHO, USD, points1[2]), SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], NU, USD, points1[3]));
PointSensitivities sensi2 = PointSensitivities.of(SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], ALPHA, USD, points2[0]), SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], BETA, USD, points2[1]), SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], RHO, USD, points2[2]), SwaptionSabrSensitivity.of(NAME, expiryTime0, TEST_TENOR[i], NU, USD, points2[3]));
PointSensitivities sensi3 = PointSensitivities.of(SwaptionSabrSensitivity.of(NAME, expiryTime3, TEST_TENOR[i], ALPHA, USD, points3[0]), SwaptionSabrSensitivity.of(NAME, expiryTime3, TEST_TENOR[i], BETA, USD, points3[1]), SwaptionSabrSensitivity.of(NAME, expiryTime3, TEST_TENOR[i], RHO, USD, points3[2]), SwaptionSabrSensitivity.of(NAME, expiryTime3, TEST_TENOR[i], NU, USD, points3[3]));
PointSensitivities sensis = sensi1.combinedWith(sensi2).combinedWith(sensi3).normalized();
CurrencyParameterSensitivities computed = prov.parameterSensitivity(sensis);
CurrencyParameterSensitivities expected = prov.parameterSensitivity(sensi1).combinedWith(prov.parameterSensitivity(sensi2)).combinedWith(prov.parameterSensitivity(sensi3));
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.AlphaSurface.Name, USD).Sensitivity.toArray(), expected.getSensitivity(PARAM.AlphaSurface.Name, USD).Sensitivity.toArray(), TOLERANCE_VOL);
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.BetaSurface.Name, USD).Sensitivity.toArray(), expected.getSensitivity(PARAM.BetaSurface.Name, USD).Sensitivity.toArray(), TOLERANCE_VOL);
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.RhoSurface.Name, USD).Sensitivity.toArray(), expected.getSensitivity(PARAM.RhoSurface.Name, USD).Sensitivity.toArray(), TOLERANCE_VOL);
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.NuSurface.Name, USD).Sensitivity.toArray(), expected.getSensitivity(PARAM.NuSurface.Name, USD).Sensitivity.toArray(), TOLERANCE_VOL);
}
}
public virtual void test_parameterSensitivity_multi()
{
double[] points1 = new double[] { 2.24, 3.45, -2.12, -0.56 };
double[] points2 = new double[] { -0.145, 1.01, -5.0, -11.0 };
double[] points3 = new double[] { 1.3, -4.32, 2.1, -7.18 };
SabrParametersIborCapletFloorletVolatilities prov = SabrParametersIborCapletFloorletVolatilities.of(NAME, EUR_EURIBOR_3M, DATE_TIME, PARAM);
double expiryTime0 = prov.relativeTime(TEST_OPTION_EXPIRY[0]);
double expiryTime3 = prov.relativeTime(TEST_OPTION_EXPIRY[3]);
for (int i = 0; i < NB_TEST; i++)
{
PointSensitivities sensi1 = PointSensitivities.of(IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, ALPHA, EUR, points1[0]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, BETA, EUR, points1[1]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, RHO, EUR, points1[2]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, NU, EUR, points1[3]));
PointSensitivities sensi2 = PointSensitivities.of(IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, ALPHA, EUR, points2[0]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, BETA, EUR, points2[1]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, RHO, EUR, points2[2]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime0, NU, EUR, points2[3]));
PointSensitivities sensi3 = PointSensitivities.of(IborCapletFloorletSabrSensitivity.of(NAME, expiryTime3, ALPHA, EUR, points3[0]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime3, BETA, EUR, points3[1]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime3, RHO, EUR, points3[2]), IborCapletFloorletSabrSensitivity.of(NAME, expiryTime3, NU, EUR, points3[3]));
PointSensitivities sensis = sensi1.combinedWith(sensi2).combinedWith(sensi3).normalized();
CurrencyParameterSensitivities computed = prov.parameterSensitivity(sensis);
CurrencyParameterSensitivities expected = prov.parameterSensitivity(sensi1).combinedWith(prov.parameterSensitivity(sensi2)).combinedWith(prov.parameterSensitivity(sensi3));
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.AlphaCurve.Name, EUR).Sensitivity.toArray(), expected.getSensitivity(PARAM.AlphaCurve.Name, EUR).Sensitivity.toArray(), TOLERANCE_VOL);
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.BetaCurve.Name, EUR).Sensitivity.toArray(), expected.getSensitivity(PARAM.BetaCurve.Name, EUR).Sensitivity.toArray(), TOLERANCE_VOL);
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.RhoCurve.Name, EUR).Sensitivity.toArray(), expected.getSensitivity(PARAM.RhoCurve.Name, EUR).Sensitivity.toArray(), TOLERANCE_VOL);
DoubleArrayMath.fuzzyEquals(computed.getSensitivity(PARAM.NuCurve.Name, EUR).Sensitivity.toArray(), expected.getSensitivity(PARAM.NuCurve.Name, EUR).Sensitivity.toArray(), TOLERANCE_VOL);
}
}
//-------------------------------------------------------------------------
public virtual void test_parameterSensitivity()
{
double expiry = ACT_365F.relativeYearFraction(VAL_DATE, LocalDate.of(2015, 8, 14));
LocalDate fixing = LocalDate.of(2016, 9, 14);
double strikePrice = 1.0025;
double futurePrice = 0.9975;
double sensitivity = 123456;
IborFutureOptionSensitivity point = IborFutureOptionSensitivity.of(VOL_SIMPLE_MONEY_RATE.Name, expiry, fixing, strikePrice, futurePrice, EUR, sensitivity);
CurrencyParameterSensitivities ps = VOL_SIMPLE_MONEY_RATE.parameterSensitivity(point);
double shift = 1.0E-6;
double v0 = VOL_SIMPLE_MONEY_RATE.volatility(expiry, fixing, strikePrice, futurePrice);
for (int i = 0; i < NORMAL_VOL_RATES.size(); i++)
{
DoubleArray v = NORMAL_VOL_RATES.with(i, NORMAL_VOL_RATES.get(i) + shift);
InterpolatedNodalSurface param = InterpolatedNodalSurface.of(Surfaces.normalVolatilityByExpirySimpleMoneyness("Rate", ACT_365F, MoneynessType.RATES), TIMES, MONEYNESS_RATES, v, INTERPOLATOR_2D);
NormalIborFutureOptionExpirySimpleMoneynessVolatilities vol = NormalIborFutureOptionExpirySimpleMoneynessVolatilities.of(EUR_EURIBOR_3M, VAL_DATE_TIME, param);
double vP = vol.volatility(expiry, fixing, strikePrice, futurePrice);
double s = ps.getSensitivity(PARAMETERS_RATE.Name, EUR).Sensitivity.get(i);
assertEquals(s, (vP - v0) / shift * sensitivity, TOLERANCE_DELTA);
}
}
//-------------------------------------------------------------------------
public virtual void regression_test()
{
double[] expected = new double[] { 3.860405407112769E7, 3.0897699603079587E7, 2.3542824458812844E7, 1.6993448607300103E7, 1.1705393621236656E7, 7865881.8260216825, 5312495.846331886, 3680367.6766224853, 2607701.430445888, 1849818.297903138, 1282881.9812227674 };
double[][][] sensiExpected = new double[][][]
{
new double[][]
{
new double[] { 0d, 0d, -1.016834993607875E8, -1.0687281893573801E8, 0d },
new double[] { 0d, 0d, 7.321670893786977E7, 7.695325324735151E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -1.0021953885887374E8, -1.0533414661787288E8, 0d },
new double[] { 0d, 0d, 7.743544635059586E7, 8.13872898657015E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -9.430418338541561E7, -9.911690666813123E7, 0d },
new double[] { 0d, 0d, 7.69436064730077E7, 8.087034941308834E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -8.284596766339977E7, -8.707393192902757E7, 0d },
new double[] { 0d, 0d, 7.031492781003796E7, 7.3903382511043E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -6.764082328040574E7, -7.109280762910862E7, 0d },
new double[] { 0d, 0d, 5.900921722111582E7, 6.2020695857797466E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -5.2035331262043096E7, -5.4690904337366335E7, 0d },
new double[] { 0d, 0d, 4.623499720852033E7, 4.859455581508104E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -3.862682913929568E7, -4.059811220715709E7, 0d },
new double[] { 0d, 0d, 3.470937255296122E7, 3.64807319923551E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -2.8260648102423556E7, -2.970290309286549E7, 0d },
new double[] { 0d, 0d, 2.554672963322189E7, 2.6850482405254934E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -2.0537629799871795E7, -2.1585747980437294E7, 0d },
new double[] { 0d, 0d, 1.8614699892839946E7, 1.9564683195371673E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -1.4728101851302534E7, -1.5479736361515924E7, 0d },
new double[] { 0d, 0d, 1.3364038126029937E7, 1.404605895619165E7, 0d }
},
new double[][]
{
new double[] { 0d, 0d, -1.0288414551608022E7, -1.0813473891259879E7, 0d },
new double[] { 0d, 0d, 9342412.029968219, 9819193.040939828, 0d }
}
};
double[][] sensiVolExpected = new double[][]
{
new double[] { -5.026579681006058E7, 1.8086314260527827E7, 3.7857814067085885E7 },
new double[] { -8.042768121510313E7, 2.6917736783424407E7, 6.828128237717555E7 },
new double[] { -7.799249393870309E7, 2.3424689020542752E7, 8.3630726080757E7 },
new double[] { -3.164036884467365E7, 7924431.550466087, 6.934450937795731E7 },
new double[] { 3.014881927958022E7, -5158819.178957329, 3.45255051012762E7 },
new double[] { 6.557093411024924E7, -1634314.6028730718, 2572569.1856012754 },
new double[] { 5.660208041880186E7, 1.8970507395428047E7, -1.03548720023163E7 },
new double[] { 1.685473267352155E7, 4.502558010977008E7, -4691785.767471665 },
new double[] { -2.724527388461766E7, 6.375255786622942E7, 9031557.200953793 },
new double[] { -5.657559310469577E7, 6.925498619398344E7, 2.0671226006236725E7 },
new double[] { -6.6067357100129634E7, 6.307938934530911E7, 2.5692820222277485E7 }
};
CurveName eurName = RatesProviderFxDataSets.getCurveName(EUR);
CurveName usdName = RatesProviderFxDataSets.getCurveName(USD);
for (int i = 0; i < NB_STRIKES; ++i)
{
// pv
CurrencyAmount computed = PRICER.presentValue(CALLS[i], RATES_PROVIDER, VOLS);
assertEquals(computed.Amount, expected[i], NOTIONAL * TOL);
// curve sensitivity
PointSensitivityBuilder point = PRICER.presentValueSensitivityRatesStickyStrike(CALLS[i], RATES_PROVIDER, VOLS);
CurrencyParameterSensitivities sensiComputed = RATES_PROVIDER.parameterSensitivity(point.build());
assertTrue(DoubleArrayMath.fuzzyEquals(sensiComputed.getSensitivity(eurName, USD).Sensitivity.toArray(), sensiExpected[i][0], NOTIONAL * TOL));
assertTrue(DoubleArrayMath.fuzzyEquals(sensiComputed.getSensitivity(usdName, USD).Sensitivity.toArray(), sensiExpected[i][1], NOTIONAL * TOL));
// vol sensitivity
PointSensitivities pointVol = PRICER.presentValueSensitivityModelParamsVolatility(CALLS[i], RATES_PROVIDER, VOLS).build();
assertEquals(pointVol.Sensitivities.get(0).Sensitivity, sensiVolExpected[i][2], NOTIONAL * TOL);
assertEquals(pointVol.Sensitivities.get(1).Sensitivity, sensiVolExpected[i][1], NOTIONAL * TOL);
assertEquals(pointVol.Sensitivities.get(2).Sensitivity, sensiVolExpected[i][0], NOTIONAL * TOL);
}
}
