public virtual void test_curveParameterSensitivity_noSensi()
{
ImmutableLegalEntityDiscountingProvider test = ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, GBP), DSC_FACTORS_ISSUER)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_ISSUER, GBP), DSC_FACTORS_REPO)).repoCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_REPO_ISSUER)).valuationDate(DATE).build();
ZeroRateSensitivity sensi = ZeroRateSensitivity.of(USD, DSC_FACTORS_ISSUER.relativeYearFraction(date(2018, 11, 24)), 25d);
CurrencyParameterSensitivities computed = test.parameterSensitivity(sensi.build());
assertEquals(computed, CurrencyParameterSensitivities.empty());
}
public virtual void test_parSpreadSensitivityWithZSpread_periodic()
{
PointSensitivities point = TRADE_PRICER.parSpreadSensitivityWithZSpread(FUTURE_TRADE, PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => CurrencyAmount.of(USD, TRADE_PRICER.parSpreadWithZSpread(FUTURE_TRADE, (p), SETTLE_PRICE, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR)));
assertTrue(computed.equalWithTolerance(expected, 10.0 * EPS * NOTIONAL * QUANTITY));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities point = PRICER.presentValueSensitivity(NDF, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(NDF, (p)));
assertTrue(computed.equalWithTolerance(expected, NOMINAL_USD * EPS_FD));
}
public virtual void test_presentValueSensitivityWithZSpread_continuous()
{
PointSensitivities point = TRADE_PRICER.presentValueSensitivityWithZSpread(FUTURE_TRADE, PROVIDER, Z_SPREAD, CONTINUOUS, 0);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => TRADE_PRICER.presentValueWithZSpread(FUTURE_TRADE, (p), SETTLE_PRICE, Z_SPREAD, CONTINUOUS, 0));
assertTrue(computed.equalWithTolerance(expected, 10.0 * EPS * NOTIONAL * QUANTITY));
}
public virtual void test_presentValueSensitivity_fixed()
{
PointSensitivities point = PRICER.presentValueSensitivity(TRADE_ILF_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValue(TRADE_ILF_STANDARD, p, ISSUER_RATES_PROVIDER)).combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValue(TRADE_ILF_STANDARD, RATES_PROVIDER, p)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}
//-------------------------------------------------------------------------
public virtual void test_defaultMethods()
{
SwaptionVolatilities test = new TestingSwaptionVolatilities();
assertEquals(test.ValuationDate, DATE_TIME.toLocalDate());
assertEquals(test.volatility(DATE_TIME, 1, 2, 3), 6d);
assertEquals(test.parameterSensitivity(), CurrencyParameterSensitivities.empty());
}
// calculates market quote sum PV01 for one scenario
internal MultiCurrencyAmount pv01MarketQuoteSum(ResolvedCdsTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData)
{
PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider, refData);
CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity);
CurrencyParameterSensitivities quoteSensitivity = MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider);
return(quoteSensitivity.total().multipliedBy(ONE_BASIS_POINT));
}
public virtual void presentValueSensitivity_buySell()
{
PointSensitivityBuilder pvBuy = PRICER_CMS.presentValueSensitivity(COUPON, RATES_PROVIDER);
PointSensitivityBuilder pvSell = PRICER_CMS.presentValueSensitivity(COUPON_SELL, RATES_PROVIDER);
CurrencyParameterSensitivities ps = RATES_PROVIDER.parameterSensitivity(pvBuy.combinedWith(pvSell).build());
assertTrue(ps.equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_DELTA));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities point = TRADE_PRICER.presentValueSensitivity(FUTURE_TRADE, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => TRADE_PRICER.presentValue(FUTURE_TRADE, (p), SETTLE_PRICE));
assertTrue(computed.equalWithTolerance(expected, 10.0 * EPS * NOTIONAL * QUANTITY));
}
// calculates market quote bucketed IR01 for one scenario
internal CurrencyParameterSensitivities ir01MarketQuoteBucketed(ResolvedCdsTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData)
{
PointSensitivities pointSensitivity = tradePricer.presentValueOnSettleSensitivity(trade, ratesProvider, refData);
CurrencyParameterSensitivity parameterSensitivity = ratesProvider.singleDiscountCurveParameterSensitivity(pointSensitivity, trade.Product.Currency);
CurrencyParameterSensitivities irSensitivity = MARKET_QUOTE_SENS.sensitivity(CurrencyParameterSensitivities.of(parameterSensitivity), ratesProvider);
return(irSensitivity.multipliedBy(ONE_BASIS_POINT));
}
public virtual void test_presentValueSensitivityWithZSpread_late()
{
PointSensitivities point = PRICER.presentValueSensitivityWithZSpread(TRADE_LATE, RATES_PROVIDER, ISSUER_RATES_PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValueWithZSpread(TRADE_LATE, p, ISSUER_RATES_PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR)).combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValueWithZSpread(TRADE_LATE, RATES_PROVIDER, p, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}
public virtual void test_presentValueSensitivityFromCleanPrice_late()
{
PointSensitivities point = PRICER.presentValueSensitivityFromCleanPrice(TRADE_LATE, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValueFromCleanPrice(TRADE_LATE, p, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE)).combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValueFromCleanPrice(TRADE_LATE, RATES_PROVIDER, p, REF_DATA, TRADE_PRICE)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}
//-------------------------------------------------------------------------
public virtual void test_parSpreadSensitivity_beforeStart()
{
PointSensitivities pts = PRICER.parSpreadSensitivity(SWAP_PRODUCT, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(pts);
CurrencyParameterSensitivities expected = CAL_FD.sensitivity(PROVIDER, (p) => CurrencyAmount.of(KRW, PRICER.parSpread(SWAP_PRODUCT, p)));
assertTrue(computed.equalWithTolerance(expected, TOLERANCE_SPREAD_DELTA));
}
public virtual void test_presentValueSensitivityFromCleanPriceWithZSpread_early_exCoupon()
{
PointSensitivities point = PRICER.presentValueSensitivityFromCleanPriceWithZSpread(TRADE_EX_COUPON_EARLY, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValueFromCleanPriceWithZSpread(TRADE_EX_COUPON_EARLY, p, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR)).combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValueFromCleanPriceWithZSpread(TRADE_EX_COUPON_EARLY, RATES_PROVIDER, p, REF_DATA, TRADE_PRICE, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}
public virtual void test_presentValueSensitivityFromCleanPriceWithZSpread_standard()
{
PointSensitivities point = PRICER.presentValueSensitivityFromCleanPriceWithZSpread(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE, Z_SPREAD, CONTINUOUS, 0);
CurrencyParameterSensitivities computed = ISSUER_RATES_PROVIDER.parameterSensitivity(point).combinedWith(RATES_PROVIDER.parameterSensitivity(point));
CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATES_PROVIDER, p => PRICER.presentValueFromCleanPriceWithZSpread(TRADE_STANDARD, p, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE, Z_SPREAD, CONTINUOUS, 0)).combinedWith(FD_CAL.sensitivity(ISSUER_RATES_PROVIDER, p => PRICER.presentValueFromCleanPriceWithZSpread(TRADE_STANDARD, RATES_PROVIDER, p, REF_DATA, TRADE_PRICE, Z_SPREAD, CONTINUOUS, 0)));
assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * EPS));
}
public virtual void test_parSpreadSensitivity_ended()
{
ResolvedFxSwap product = ResolvedFxSwap.ofForwardPoints(CurrencyAmount.of(USD, NOMINAL_USD), KRW, FX_RATE, FX_FWD_POINTS, PAYMENT_DATE_LONG_PAST, PAYMENT_DATE_PAST);
PointSensitivities pts = PRICER.parSpreadSensitivity(product, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(pts);
assertTrue(computed.equalWithTolerance(CurrencyParameterSensitivities.empty(), TOLERANCE_SPREAD_DELTA));
}
public virtual void test_presentValueSensitivity()
{
PointSensitivities point = PRICER.presentValueSensitivity(FWD, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point);
CurrencyParameterSensitivities expectedUsd = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(FWD, (p)).getAmount(USD));
CurrencyParameterSensitivities expectedKrw = CAL_FD.sensitivity(PROVIDER, (p) => PRICER.presentValue(FWD, (p)).getAmount(KRW));
assertTrue(computed.equalWithTolerance(expectedUsd.combinedWith(expectedKrw), NOMINAL_USD * FX_RATE * EPS_FD));
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivity_fixing()
{
PointSensitivities computedNoFix = PRICER.presentValueSensitivity(RDEPOSIT, IMM_PROV_NOFIX);
CurrencyParameterSensitivities sensiComputedNoFix = IMM_PROV_NOFIX.parameterSensitivity(computedNoFix);
PointSensitivities computedFix = PRICER.presentValueSensitivity(RDEPOSIT, IMM_PROV_FIX);
CurrencyParameterSensitivities sensiComputedFix = IMM_PROV_NOFIX.parameterSensitivity(computedFix);
assertTrue(sensiComputedNoFix.equalWithTolerance(sensiComputedFix, TOLERANCE_PV_DELTA));
}
public virtual void test_parSpreadSensitivity_started()
{
ResolvedFxSwap product = ResolvedFxSwap.ofForwardPoints(CurrencyAmount.of(USD, NOMINAL_USD), KRW, FX_RATE, FX_FWD_POINTS, PAYMENT_DATE_PAST, PAYMENT_DATE_NEAR);
PointSensitivities pts = PRICER.parSpreadSensitivity(product, PROVIDER);
CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(pts);
CurrencyParameterSensitivities expected = CAL_FD.sensitivity(PROVIDER, (p) => CurrencyAmount.of(KRW, PRICER.parSpread(product, p)));
assertTrue(computed.equalWithTolerance(expected, TOLERANCE_SPREAD_DELTA));
}
public virtual void present_value_sensitivity_premium_past()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREPAST_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, MULTI_USD, NORMAL_VOLS_USD);
CurrencyParameterSensitivities pvpsTrade = MULTI_USD.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = MULTI_USD.parameterSensitivity(pvcsProduct.build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, TOLERANCE_PV_DELTA));
}
//-------------------------------------------------------------------------
private static CurrencyParameterSensitivity buildSensitivities(Curve bumpedCurve, ImmutableRatesProvider ratesProvider)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
RatesProvider bumpedRatesProvider = ratesProvider.toBuilder().discountCurves(ratesProvider.DiscountCurves.Keys.collect(toImmutableMap(System.Func.identity(), k => bumpedCurve))).indexCurves(ratesProvider.IndexCurves.Keys.collect(toImmutableMap(System.Func.identity(), k => bumpedCurve))).build();
PointSensitivities pointSensitivities = PRICER_SWAP.presentValueSensitivity(SWAP, bumpedRatesProvider).build();
CurrencyParameterSensitivities paramSensitivities = bumpedRatesProvider.parameterSensitivity(pointSensitivities);
return(Iterables.getOnlyElement(paramSensitivities.Sensitivities));
}
public virtual void test_parameterSensitivity()
{
RepoCurveDiscountFactors @base = RepoCurveDiscountFactors.of(DSC_FACTORS, GROUP);
RepoCurveZeroRateSensitivity sensi = @base.zeroRatePointSensitivity(DATE_AFTER, USD);
CurrencyParameterSensitivities computed = @base.parameterSensitivity(sensi);
CurrencyParameterSensitivities expected = DSC_FACTORS.parameterSensitivity(DSC_FACTORS.zeroRatePointSensitivity(DATE_AFTER, USD));
assertEquals(computed, expected);
}
// Checks that the NDF present value sensitivity is coherent with the standard FX forward present value.
public virtual void test_presentValueCurveSensitivityVsForex()
{
PointSensitivities pvcsNDF = PRICER.presentValueSensitivity(NDF, PROVIDER).normalized();
CurrencyParameterSensitivities sensiNDF = PROVIDER.parameterSensitivity(pvcsNDF);
PointSensitivities pvcsFX = PRICER_FX.presentValueSensitivity(FOREX, PROVIDER).normalized();
CurrencyParameterSensitivities sensiFX = PROVIDER.parameterSensitivity(pvcsFX);
assertTrue(sensiNDF.equalWithTolerance(sensiFX.convertedTo(USD, PROVIDER), NOMINAL_USD * TOL));
}
public virtual void present_value_sensitivity_premium_past()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRates(SWAPTION_PREPAST_LONG_REC, MULTI_USD, HW_PROVIDER);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRates(SWAPTION_LONG_REC, MULTI_USD, HW_PROVIDER);
CurrencyParameterSensitivities pvpsTrade = MULTI_USD.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = MULTI_USD.parameterSensitivity(pvcsProduct.build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, TOL * NOTIONAL));
}
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 present_value_sensitivity_premium_past()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(SWAPTION_PREPAST_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyStrike(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS);
CurrencyParameterSensitivities pvpsTrade = RATE_PROVIDER.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = RATE_PROVIDER.parameterSensitivity(pvcsProduct.build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, NOTIONAL * TOL));
}
static MarketQuoteSensitivityCalculatorTest()
{
CurrencyParameterSensitivity sensi1 = CurrencyParameterSensitivity.of(CURVE_NAME_1, USD, SENSI_1);
CurrencyParameterSensitivity sensi2 = CurrencyParameterSensitivity.of(CURVE_NAME_2, GBP, SENSI_2);
ZeroRateDiscountFactors dscIssuer = ZeroRateDiscountFactors.of(USD, DATE, CURVE_1);
ZeroRateDiscountFactors dscRepo = ZeroRateDiscountFactors.of(GBP, DATE, CURVE_2);
PARAMETER_SENSITIVITIES = CurrencyParameterSensitivities.of(sensi1, sensi2);
PROVIDER = ImmutableLegalEntityDiscountingProvider.builder().issuerCurves(ImmutableMap.of(Pair.of(GROUP_ISSUER, USD), dscIssuer)).issuerCurveGroups(ImmutableMap.of(ID_ISSUER, GROUP_ISSUER)).repoCurves(ImmutableMap.of(Pair.of(GROUP_REPO_SECURITY, GBP), dscRepo)).repoCurveSecurityGroups(ImmutableMap.of(ID_SECURITY, GROUP_REPO_SECURITY)).build();
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the FX barrier option trade.
/// <para>
/// The present value sensitivity of the trade is the sensitivity of the present value to
/// the underlying curves.
/// </para>
/// <para>
/// The sensitivity is computed by bump and re-price, returning <seealso cref="CurrencyParameterSensitivities"/>,
/// not <seealso cref="PointSensitivities"/>.
/// </para>
/// <para>
/// The trinomial tree is first calibrated to Black volatilities,
/// then the price is computed based on the calibrated tree.
///
/// </para>
/// </summary>
/// <param name="trade"> the option trade </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value curve sensitivity of the trade </returns>
public virtual CurrencyParameterSensitivities presentValueSensitivityRates(ResolvedFxSingleBarrierOptionTrade trade, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
ResolvedFxSingleBarrierOption product = trade.Product;
CurrencyParameterSensitivities sensProduct = productPricer.presentValueSensitivityRates(product, ratesProvider, volatilities);
Payment premium = trade.Premium;
PointSensitivityBuilder pvcsPremium = paymentPricer.presentValueSensitivity(premium, ratesProvider);
CurrencyParameterSensitivities sensPremium = ratesProvider.parameterSensitivity(pvcsPremium.build());
return(sensProduct.combinedWith(sensPremium));
}
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 present_value_sensitivity_premium_forward()
{
PointSensitivities pvcsTrade = PRICER_TRADE.presentValueSensitivityRatesStickyModel(SWAPTION_PREFWD_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsProduct = PRICER_PRODUCT.presentValueSensitivityRatesStickyModel(SWAPTION_LONG_REC, RATE_PROVIDER, VOLS);
PointSensitivityBuilder pvcsPremium = PRICER_PAYMENT.presentValueSensitivity(PREMIUM_FWD_PAY, RATE_PROVIDER);
CurrencyParameterSensitivities pvpsTrade = RATE_PROVIDER.parameterSensitivity(pvcsTrade);
CurrencyParameterSensitivities pvpsProduct = RATE_PROVIDER.parameterSensitivity(pvcsProduct.combinedWith(pvcsPremium).build());
assertTrue(pvpsTrade.equalWithTolerance(pvpsProduct, NOTIONAL * NOTIONAL * TOL));
}
