public virtual void test_presentValueSensitivity_parity()
{
CurrencyParameterSensitivities pvSensiRecLong = RATE_PROVIDER.parameterSensitivity(PRICER.presentValueSensitivityRates(SWAPTION_REC_LONG, RATE_PROVIDER, HW_PROVIDER).build());
CurrencyParameterSensitivities pvSensiRecShort = RATE_PROVIDER.parameterSensitivity(PRICER.presentValueSensitivityRates(SWAPTION_REC_SHORT, RATE_PROVIDER, HW_PROVIDER).build());
CurrencyParameterSensitivities pvSensiPayLong = RATE_PROVIDER.parameterSensitivity(PRICER.presentValueSensitivityRates(SWAPTION_PAY_LONG, RATE_PROVIDER, HW_PROVIDER).build());
CurrencyParameterSensitivities pvSensiPayShort = RATE_PROVIDER.parameterSensitivity(PRICER.presentValueSensitivityRates(SWAPTION_PAY_SHORT, RATE_PROVIDER, HW_PROVIDER).build());
assertTrue(pvSensiRecLong.equalWithTolerance(pvSensiRecShort.multipliedBy(-1d), NOTIONAL * TOL));
assertTrue(pvSensiPayLong.equalWithTolerance(pvSensiPayShort.multipliedBy(-1d), NOTIONAL * TOL));
PointSensitivities expectedPoint = SWAP_PRICER.presentValueSensitivity(RSWAP_PAY, RATE_PROVIDER).build();
CurrencyParameterSensitivities expected = RATE_PROVIDER.parameterSensitivity(expectedPoint);
assertTrue(expected.equalWithTolerance(pvSensiPayLong.combinedWith(pvSensiRecLong.multipliedBy(-1d)), NOTIONAL * TOL));
assertTrue(expected.equalWithTolerance(pvSensiRecShort.combinedWith(pvSensiPayShort.multipliedBy(-1d)), NOTIONAL * TOL));
}
public virtual void test_pv01_quote()
{
BillTradeCalculationFunction <BillTrade> function = BillTradeCalculationFunction.TRADE;
ScenarioMarketData md = marketData();
LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider();
DiscountingBillTradePricer pricer = DiscountingBillTradePricer.DEFAULT;
PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, provider);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
CurrencyParameterSensitivities expectedPv01CalBucketed = MQ_CALC.sensitivity(pvParamSens, provider).multipliedBy(1e-4);
MultiCurrencyAmount expectedPv01Cal = expectedPv01CalBucketed.total();
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_MARKET_QUOTE_SUM, Measures.PV01_MARKET_QUOTE_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_MARKET_QUOTE_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal)))).containsEntry(Measures.PV01_MARKET_QUOTE_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed))));
}
public virtual void regressionPvCurveSensi()
{
PointSensitivityBuilder point = SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS_REGRESSION);
CurrencyParameterSensitivities sensiComputed = RATE_PROVIDER.parameterSensitivity(point.build());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double[] deltaDsc = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 109037.92080563342, 637123.4570377409, -931862.187003511, -2556192.7520530378, -4233440.216336116, -5686205.439275854, -6160338.898970505, -3709275.494841247, 0.0};
double[] deltaDsc = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 109037.92080563342, 637123.4570377409, -931862.187003511, -2556192.7520530378, -4233440.216336116, -5686205.439275854, -6160338.898970505, -3709275.494841247, 0.0 };
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double[] deltaFwd = {0.0, 0.0, 0.0, 0.0, -1.0223186788452002E8, 2506923.9169937484, 4980364.73045286, 1.254633556119663E7, 1.528160539036628E8, 2.5824191204559547E8, 0.0, 0.0, 0.0, 0.0, 0.0};
double[] deltaFwd = new double[] { 0.0, 0.0, 0.0, 0.0, -1.0223186788452002E8, 2506923.9169937484, 4980364.73045286, 1.254633556119663E7, 1.528160539036628E8, 2.5824191204559547E8, 0.0, 0.0, 0.0, 0.0, 0.0 };
CurrencyParameterSensitivities sensiExpected = CurrencyParameterSensitivities.of(SwaptionSabrRateVolatilityDataSet.CURVE_DSC_USD.createParameterSensitivity(USD, DoubleArray.copyOf(deltaDsc)), SwaptionSabrRateVolatilityDataSet.CURVE_FWD_USD.createParameterSensitivity(USD, DoubleArray.copyOf(deltaFwd)));
assertTrue(sensiComputed.equalWithTolerance(sensiExpected, NOTIONAL * REGRESSION_TOL));
}
// computes the sensitivity of baseDeltaSingle to Curve
internal CrossGammaParameterSensitivity computeGammaForCurve(CurrencyParameterSensitivity baseDeltaSingle, Curve curve, System.Func <Curve, ImmutableRatesProvider> ratesProviderFn, System.Func <ImmutableRatesProvider, CurrencyParameterSensitivities> sensitivitiesFn)
{
System.Func <DoubleArray, DoubleArray> function = (DoubleArray t) =>
{
Curve newCurve = replaceParameters(curve, t);
ImmutableRatesProvider newRates = ratesProviderFn(newCurve);
CurrencyParameterSensitivities sensiMulti = sensitivitiesFn(newRates);
return(sensiMulti.getSensitivity(baseDeltaSingle.MarketDataName, baseDeltaSingle.Currency).Sensitivity);
};
int nParams = curve.ParameterCount;
DoubleMatrix sensi = fd.differentiate(function).apply(DoubleArray.of(nParams, n => curve.getParameter(n)));
IList <ParameterMetadata> metadata = IntStream.range(0, nParams).mapToObj(i => curve.getParameterMetadata(i)).collect(toImmutableList());
return(CrossGammaParameterSensitivity.of(baseDeltaSingle.MarketDataName, baseDeltaSingle.ParameterMetadata, curve.Name, metadata, baseDeltaSingle.Currency, sensi));
}
private CrossGammaParameterSensitivity computeGammaForCurve(CurveName curveName, Curve curve, Currency sensitivityCurrency, System.Func <Curve, ImmutableLegalEntityDiscountingProvider> ratesProviderFn, System.Func <ImmutableLegalEntityDiscountingProvider, CurrencyParameterSensitivities> sensitivitiesFn)
{
System.Func <DoubleArray, DoubleArray> function = (DoubleArray t) =>
{
Curve newCurve = curve.withPerturbation((i, v, m) => t.get(i));
ImmutableLegalEntityDiscountingProvider newRates = ratesProviderFn(newCurve);
CurrencyParameterSensitivities sensiMulti = sensitivitiesFn(newRates);
return(sensiMulti.getSensitivity(curveName, sensitivityCurrency).Sensitivity);
};
int nParams = curve.ParameterCount;
DoubleMatrix sensi = fd.differentiate(function).apply(DoubleArray.of(nParams, n => curve.getParameter(n)));
IList <ParameterMetadata> metadata = IntStream.range(0, nParams).mapToObj(i => curve.getParameterMetadata(i)).collect(toImmutableList());
return(CrossGammaParameterSensitivity.of(curveName, metadata, sensitivityCurrency, sensi));
}
public virtual void test_presentValueSensitivity_parity()
{
CurrencyParameterSensitivities pvSensiRecLong = RATE_PROVIDER.parameterSensitivity(SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(SWAPTION_REC_LONG, RATE_PROVIDER, VOLS).build());
CurrencyParameterSensitivities pvSensiRecShort = RATE_PROVIDER.parameterSensitivity(SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(SWAPTION_REC_SHORT, RATE_PROVIDER, VOLS).build());
CurrencyParameterSensitivities pvSensiPayLong = RATE_PROVIDER.parameterSensitivity(SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(SWAPTION_PAY_LONG, RATE_PROVIDER, VOLS).build());
CurrencyParameterSensitivities pvSensiPayShort = RATE_PROVIDER.parameterSensitivity(SWAPTION_PRICER.presentValueSensitivityRatesStickyModel(SWAPTION_PAY_SHORT, RATE_PROVIDER, VOLS).build());
assertTrue(pvSensiRecLong.equalWithTolerance(pvSensiRecShort.multipliedBy(-1d), NOTIONAL * TOL));
assertTrue(pvSensiPayLong.equalWithTolerance(pvSensiPayShort.multipliedBy(-1d), NOTIONAL * TOL));
CurrencyParameterSensitivities pvSensiSwap = RATE_PROVIDER.parameterSensitivity(SWAP_PRICER.presentValueSensitivity(RSWAP_PAY, RATE_PROVIDER).build());
assertTrue(pvSensiSwap.equalWithTolerance(pvSensiPayLong.combinedWith(pvSensiRecLong.multipliedBy(-1d)), NOTIONAL * TOL));
assertTrue(pvSensiSwap.equalWithTolerance(pvSensiRecShort.combinedWith(pvSensiPayShort.multipliedBy(-1d)), NOTIONAL * TOL));
}
public virtual void test_pv01()
{
BondFutureOptionTradeCalculationFunction <BondFutureOptionTrade> function = BondFutureOptionTradeCalculationFunction.TRADE;
ScenarioMarketData md = marketData();
LegalEntityDiscountingProvider provider = LED_LOOKUP.marketDataView(md.scenario(0)).discountingProvider();
BlackBondFutureOptionMarginedTradePricer pricer = BlackBondFutureOptionMarginedTradePricer.DEFAULT;
PointSensitivities pvPointSens = pricer.presentValueSensitivityRates(RTRADE, provider, VOLS);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01Cal = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedPv01CalBucketed = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed))));
}
public virtual void test_pv01()
{
FxSingleBarrierOptionTradeCalculationFunction function = new FxSingleBarrierOptionTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
BlackFxSingleBarrierOptionTradePricer pricer = BlackFxSingleBarrierOptionTradePricer.DEFAULT;
PointSensitivities pvPointSens = pricer.presentValueSensitivityRatesStickyStrike(RTRADE, provider, VOLS);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01 = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedBucketedPv01 = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedBucketedPv01))));
}
//-------------------------------------------------------------------------
// price and vega function
private System.Func <double, double[]> getValueVegaFunction(ResolvedIborCapFloorLeg cap, RatesProvider ratesProvider, IborCapletFloorletVolatilities vols, ZonedDateTime prevExpiry, int nodeIndex)
{
VolatilityIborCapletFloorletPeriodPricer periodPricer = LegPricer.PeriodPricer;
System.Func <double, double[]> priceAndVegaFunction = (double?x) =>
{
IborCapletFloorletVolatilities newVols = vols.withParameter(nodeIndex, x.Value);
double price = cap.CapletFloorletPeriods.Where(p => p.FixingDateTime.isAfter(prevExpiry)).Select(p => periodPricer.presentValue(p, ratesProvider, newVols).Amount).Sum();
PointSensitivities point = cap.CapletFloorletPeriods.Where(p => p.FixingDateTime.isAfter(prevExpiry)).Select(p => periodPricer.presentValueSensitivityModelParamsVolatility(p, ratesProvider, newVols)).Aggregate((c1, c2) => c1.combinedWith(c2)).get().build();
CurrencyParameterSensitivities sensi = newVols.parameterSensitivity(point);
double vega = sensi.Sensitivities.get(0).Sensitivity.get(nodeIndex);
return(new double[] { price, vega });
};
return(priceAndVegaFunction);
}
public virtual void check_equivalent_notional()
{
ImmutableRatesProvider multicurve = CALIBRATOR.calibrate(GROUP_DEFINITION_PV_SENSI, MARKET_QUOTES, REF_DATA);
// Create notional equivalent for a basis trade
ResolvedSwapTrade trade = ThreeLegBasisSwapConventions.EUR_FIXED_1Y_EURIBOR_3M_EURIBOR_6M.createTrade(VALUATION_DATE, Period.ofMonths(7), Tenor.TENOR_6Y, BuySell.SELL, 1_000_000, 0.03, REF_DATA).resolve(REF_DATA);
PointSensitivities pts = PRICER_SWAP_TRADE.presentValueSensitivity(trade, multicurve);
CurrencyParameterSensitivities ps = multicurve.parameterSensitivity(pts);
CurrencyParameterSensitivities mqs = MQSC.sensitivity(ps, multicurve);
CurrencyParameterSensitivities notionalEquivalent = NEC.notionalEquivalent(mqs, multicurve);
// Check metadata are same as market quote sensitivities.
foreach (CurrencyParameterSensitivity sensi in mqs.Sensitivities)
{
assertEquals(notionalEquivalent.getSensitivity(sensi.MarketDataName, sensi.Currency).ParameterMetadata, sensi.ParameterMetadata);
}
// Check sensitivity: trade sensitivity = sum(notional equivalent sensitivities)
int totalNbParameters = 0;
IDictionary <CurveName, IList <ResolvedTrade> > equivalentTrades = new Dictionary <CurveName, IList <ResolvedTrade> >();
ImmutableList <CurveDefinition> curveGroups = GROUP_DEFINITION.CurveDefinitions;
ImmutableList.Builder <CurveParameterSize> builder = ImmutableList.builder();
foreach (CurveDefinition entry in curveGroups)
{
totalNbParameters += entry.ParameterCount;
DoubleArray notionalCurve = notionalEquivalent.getSensitivity(entry.Name, Currency.EUR).Sensitivity;
ImmutableList <CurveNode> nodes = entry.Nodes;
IList <ResolvedTrade> resolvedTradesCurve = new List <ResolvedTrade>();
for (int i = 0; i < nodes.size(); i++)
{
resolvedTradesCurve.Add(nodes.get(i).resolvedTrade(notionalCurve.get(i), MARKET_QUOTES, REF_DATA));
}
equivalentTrades[entry.Name] = resolvedTradesCurve;
builder.add(entry.toCurveParameterSize());
}
ImmutableList <CurveParameterSize> order = builder.build(); // order of the curves
DoubleArray totalSensitivity = DoubleArray.filled(totalNbParameters);
foreach (KeyValuePair <CurveName, IList <ResolvedTrade> > entry in equivalentTrades.SetOfKeyValuePairs())
{
foreach (ResolvedTrade t in entry.Value)
{
totalSensitivity = totalSensitivity.plus(PV_MEASURES.derivative(t, multicurve, order));
}
}
DoubleArray instrumentSensi = PV_MEASURES.derivative(trade, multicurve, order);
assertTrue(totalSensitivity.equalWithTolerance(instrumentSensi, TOLERANCE_PV_DELTA));
}
//-------------------------------------------------------------------------
public virtual void test_forecastValueSensitivity()
{
ImmutableRatesProvider prov = ImmutableRatesProvider.builder(VAL_DATE).fxRateProvider(FX_MATRIX).discountCurve(GBP, DISCOUNT_CURVE_GBP).discountCurve(USD, DISCOUNT_CURVE_USD).build();
FxResetNotionalExchange[] expanded = new FxResetNotionalExchange[] { FX_RESET_NOTIONAL_EXCHANGE_REC_USD, FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP };
for (int i = 0; i < 2; ++i)
{
FxResetNotionalExchange fxReset = expanded[i];
DiscountingFxResetNotionalExchangePricer test = new DiscountingFxResetNotionalExchangePricer();
PointSensitivityBuilder pointSensitivityComputed = test.forecastValueSensitivity(expanded[i], prov);
CurrencyParameterSensitivities parameterSensitivityComputed = prov.parameterSensitivity(pointSensitivityComputed.build());
CurrencyParameterSensitivities parameterSensitivityExpected = FD_CALCULATOR.sensitivity(prov, (p) => CurrencyAmount.of(fxReset.Currency, test.forecastValue(fxReset, (p))));
assertTrue(parameterSensitivityComputed.equalWithTolerance(parameterSensitivityExpected, Math.Abs(expanded[i].Notional) * EPS_FD * 10.0));
}
}
public virtual void test_pv01()
{
TermDepositTradeCalculationFunction function = new TermDepositTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
DiscountingTermDepositProductPricer pricer = DiscountingTermDepositProductPricer.DEFAULT;
ResolvedTermDeposit resolved = TRADE.Product.resolve(REF_DATA);
PointSensitivities pvPointSens = pricer.presentValueSensitivity(resolved, provider);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01 = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedBucketedPv01 = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedBucketedPv01))));
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(IborRateSensitivity pointSensitivity)
{
LocalDate fixingStartDate = pointSensitivity.Observation.EffectiveDate;
LocalDate fixingEndDate = pointSensitivity.Observation.MaturityDate;
double accrualFactor = pointSensitivity.Observation.YearFraction;
double forwardBar = pointSensitivity.Sensitivity;
double dfForwardStart = discountFactors.discountFactor(fixingStartDate);
double dfForwardEnd = discountFactors.discountFactor(fixingEndDate);
double dfStartBar = forwardBar / (accrualFactor * dfForwardEnd);
double dfEndBar = -forwardBar * dfForwardStart / (accrualFactor * dfForwardEnd * dfForwardEnd);
ZeroRateSensitivity zrsStart = discountFactors.zeroRatePointSensitivity(fixingStartDate, pointSensitivity.Currency);
ZeroRateSensitivity zrsEnd = discountFactors.zeroRatePointSensitivity(fixingEndDate, pointSensitivity.Currency);
CurrencyParameterSensitivities psStart = discountFactors.parameterSensitivity(zrsStart).multipliedBy(dfStartBar);
CurrencyParameterSensitivities psEnd = discountFactors.parameterSensitivity(zrsEnd).multipliedBy(dfEndBar);
return(psStart.combinedWith(psEnd));
}
public CurrencyParameterSensitivities parameterSensitivity(PointSensitivities pointSensitivities)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is FxOptionSensitivity)
{
FxOptionSensitivity pt = (FxOptionSensitivity)point;
if (pt.VolatilitiesName.Equals(Name))
{
sens = sens.combinedWith(parameterSensitivity(pt));
}
}
}
return(sens);
}
// modified sensitivity function - sensitivities are computed only for ibor index curves
private CurrencyParameterSensitivities sensiModFn(ImmutableRatesProvider provider)
{
CurrencyParameterSensitivities sensi = CurrencyParameterSensitivities.empty();
// Index
ImmutableMap <Index, Curve> mapIndex = provider.IndexCurves;
foreach (KeyValuePair <Index, Curve> entry in mapIndex.entrySet())
{
if (entry.Key is IborIndex)
{
InterpolatedNodalCurve curveInt = checkInterpolated(entry.Value);
double sumSqrt = sumMod(provider);
sensi = sensi.combinedWith(CurrencyParameterSensitivity.of(curveInt.Name, USD, DoubleArray.of(curveInt.ParameterCount, i => 2d * sumSqrt * curveInt.XValues.get(i))));
}
}
return(sensi);
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(OvernightRateSensitivity pointSensitivity)
{
OvernightIndex index = pointSensitivity.Index;
LocalDate startDate = pointSensitivity.Observation.EffectiveDate;
LocalDate endDate = pointSensitivity.EndDate;
double accrualFactor = index.DayCount.yearFraction(startDate, endDate);
double forwardBar = pointSensitivity.Sensitivity;
double dfForwardStart = discountFactors.discountFactor(startDate);
double dfForwardEnd = discountFactors.discountFactor(endDate);
double dfStartBar = forwardBar / (accrualFactor * dfForwardEnd);
double dfEndBar = -forwardBar * dfForwardStart / (accrualFactor * dfForwardEnd * dfForwardEnd);
ZeroRateSensitivity zrsStart = discountFactors.zeroRatePointSensitivity(startDate, pointSensitivity.Currency);
ZeroRateSensitivity zrsEnd = discountFactors.zeroRatePointSensitivity(endDate, pointSensitivity.Currency);
CurrencyParameterSensitivities psStart = discountFactors.parameterSensitivity(zrsStart).multipliedBy(dfStartBar);
CurrencyParameterSensitivities psEnd = discountFactors.parameterSensitivity(zrsEnd).multipliedBy(dfEndBar);
return(psStart.combinedWith(psEnd));
}
/// <summary>
/// Computes the row corresponding to a trade for the Jacobian matrix.
/// </summary>
/// <param name="curveOrder"> the curve order </param>
/// <param name="parameterSensitivities"> the sensitivities </param>
/// <param name="ccy"> the currency common to all sensitivities </param>
/// <returns> the row </returns>
private static DoubleArray row(IList <CurveParameterSize> curveOrder, CurrencyParameterSensitivities parameterSensitivities, Currency ccy)
{
DoubleArray row = DoubleArray.EMPTY;
foreach (CurveParameterSize curveNameAndSize in curveOrder)
{
Optional <CurrencyParameterSensitivity> sensitivityOneCurve = parameterSensitivities.findSensitivity(curveNameAndSize.Name, ccy);
if (sensitivityOneCurve.Present)
{
row = row.concat(sensitivityOneCurve.get().Sensitivity);
}
else
{
row = row.concat(DoubleArray.filled(curveNameAndSize.ParameterCount));
}
}
return(row);
}
public virtual void test_curveSensitivityMeasures()
{
double oneBp = 1e-4;
PointSensitivities pvPointSens = PRICER.presentValueSensitivity(RTRADE, RATES_PROVIDER, CreditDataSet.REF_DATA);
CurrencyParameterSensitivities pvParamSens = RATES_PROVIDER.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01Cal = pvParamSens.total().multipliedBy(oneBp);
CurrencyParameterSensitivities expectedPv01CalBucketed = pvParamSens.multipliedBy(oneBp);
CurrencyParameterSensitivity expectedCs01Bucketed = CS01_CALC.bucketedCs01(RTRADE, RATES_PROVIDER, CreditDataSet.REF_DATA);
CurrencyAmount expectedCs01Parallel = CS01_CALC.parallelCs01(RTRADE, RATES_PROVIDER, CreditDataSet.REF_DATA);
PointSensitivities pvPointSensOnSettle = PRICER.presentValueOnSettleSensitivity(RTRADE, RATES_PROVIDER, CreditDataSet.REF_DATA);
CurrencyParameterSensitivity ir01 = RATES_PROVIDER.singleDiscountCurveParameterSensitivity(pvPointSensOnSettle, USD);
CurrencyAmount expectedIr01Cal = ir01.total().multipliedBy(oneBp);
CurrencyParameterSensitivity expectedIr01CalBucketed = ir01.multipliedBy(oneBp);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED, CreditMeasures.CS01_PARALLEL, CreditMeasures.CS01_BUCKETED, CreditMeasures.IR01_CALIBRATED_PARALLEL, CreditMeasures.IR01_CALIBRATED_BUCKETED);
assertThat(FUNCTION.calculate(TRADE, measures, CreditDataSet.CDS_PARAMS, CreditDataSet.MARKET_DATA, CreditDataSet.REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed)))).containsEntry(CreditMeasures.CS01_PARALLEL, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedCs01Parallel)))).containsEntry(CreditMeasures.CS01_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedCs01Bucketed)))).containsEntry(CreditMeasures.IR01_CALIBRATED_PARALLEL, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedIr01Cal)))).containsEntry(CreditMeasures.IR01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedIr01CalBucketed))));
}
/// <summary>
/// Exports into a csv file a <seealso cref="CurrencyParameterSensitivities"/>, which is the sensitivity with respect to
/// multiple curves or surfaces.
/// <para>
/// In the export the figures are often scaled to match market conventions, for examples a one basis point
/// scaling for interest rate curves. The factor can be provided and will apply to all points of the sensitivity.
///
/// </para>
/// </summary>
/// <param name="sensitivity"> the sensitivity object </param>
/// <param name="scale"> the scaling factor </param>
/// <param name="fileName"> the file name for the export </param>
public static void export(CurrencyParameterSensitivities sensitivity, double scale, string fileName)
{
ImmutableList <CurrencyParameterSensitivity> sl = sensitivity.Sensitivities;
string output = "Label, Value\n";
foreach (CurrencyParameterSensitivity s in sl)
{
output = output + s.MarketDataName.ToString() + ", " + s.Currency.ToString() + "\n";
ArgChecker.isTrue(s.ParameterMetadata.size() > 0, "Parameters metadata required");
DoubleArray sa = s.Sensitivity;
IList <ParameterMetadata> pmd = s.ParameterMetadata;
for (int loopnode = 0; loopnode < sa.size(); loopnode++)
{
output = output + pmd[loopnode].Label + ", " + (sa.get(loopnode) * scale) + "\n";
}
}
export(output, fileName);
}
private void test_from_functions_one_curve_one_date(System.Func <LocalDate, ParameterMetadata> parameterMetadataFunction, System.Func <CurrencyParameterSensitivities, CurrencyParameterSensitivities> rebucketFunction)
{
for (int loopdate = 0; loopdate < SENSITIVITY_DATES.Count; loopdate++)
{
IList <ParameterMetadata> pmdInput = new List <ParameterMetadata>();
pmdInput.Add(parameterMetadataFunction(SENSITIVITY_DATES[loopdate]));
CurrencyParameterSensitivity s = CurrencyParameterSensitivity.of(NAME_1, pmdInput, CCY_1, DoubleArray.of(SENSITIVITY_AMOUNT));
CurrencyParameterSensitivities s2 = CurrencyParameterSensitivities.of(s);
CurrencyParameterSensitivities sTarget = rebucketFunction(s2);
assertTrue(sTarget.Sensitivities.size() == 1);
CurrencyParameterSensitivity sTarget1 = sTarget.Sensitivities.get(0);
assertTrue(sTarget1.MarketDataName.Equals(NAME_1));
assertTrue(sTarget1.Currency.Equals(CCY_1));
assertTrue(sTarget1.Sensitivity.size() == TARGET_DATES.Count);
assertEquals(sTarget1.Sensitivity.get(WEIGHTS_START[loopdate]), WEIGHTS_HC[loopdate] * SENSITIVITY_AMOUNT, TOLERANCE_SENSI);
assertEquals(sTarget1.Sensitivity.get(WEIGHTS_START[loopdate] + 1), (1.0d - WEIGHTS_HC[loopdate]) * SENSITIVITY_AMOUNT, TOLERANCE_SENSI);
}
}
public virtual void parSpreadSensitivityTest()
{
PointSensitivityBuilder point = PRICER.parSpreadSensitivity(PRODUCT, RATES_PROVIDER, SETTLEMENT_STD, REF_DATA);
CurrencyParameterSensitivities res = RATES_PROVIDER.parameterSensitivity(point.build());
CurrencyParameterSensitivities exp = CALC_FD.sensitivity(RATES_PROVIDER, p => CurrencyAmount.of(USD, PRICER.parSpread(PRODUCT, p, SETTLEMENT_STD, REF_DATA)));
equalWithRelativeTolerance(res, exp, NOTIONAL * EPS);
PointSensitivityBuilder pointMarkit = PRICER_MARKIT.parSpreadSensitivity(PRODUCT, RATES_PROVIDER, SETTLEMENT_STD, REF_DATA);
CurrencyParameterSensitivities resMarkit = RATES_PROVIDER.parameterSensitivity(pointMarkit.build());
CurrencyParameterSensitivities expMarkit = CALC_FD.sensitivity(RATES_PROVIDER, p => CurrencyAmount.of(USD, PRICER_MARKIT.parSpread(PRODUCT, p, SETTLEMENT_STD, REF_DATA)));
equalWithRelativeTolerance(resMarkit, expMarkit, NOTIONAL * EPS);
PointSensitivityBuilder pointOg = PRICER_OG.parSpreadSensitivity(PRODUCT, RATES_PROVIDER, SETTLEMENT_STD, REF_DATA);
CurrencyParameterSensitivities resOg = RATES_PROVIDER.parameterSensitivity(pointOg.build());
CurrencyParameterSensitivities expOg = CALC_FD.sensitivity(RATES_PROVIDER, p => CurrencyAmount.of(USD, PRICER_OG.parSpread(PRODUCT, p, SETTLEMENT_STD, REF_DATA)));
equalWithRelativeTolerance(resOg, expOg, NOTIONAL * EPS);
}
public virtual void test_builder_tenors()
{
CurveName curveName = CurveName.of("GBP");
CurrencyParameterSensitivity sens1Y = CurrencyParameterSensitivity.of(curveName, ImmutableList.of(TENOR_MD_1Y), GBP, DoubleArray.of(3));
CurveSensitivities test = CurveSensitivities.builder(PortfolioItemInfo.empty()).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1M, 4).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1W, 1).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1Y, 2).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1W, 2).add(ZERO_RATE_DELTA, sens1Y).build();
assertEquals(test.Info, PortfolioItemInfo.empty());
assertEquals(test.TypedSensitivities.size(), 1);
CurrencyParameterSensitivities sens = test.getTypedSensitivity(ZERO_RATE_DELTA);
assertEquals(sens.Sensitivities.size(), 1);
CurrencyParameterSensitivity singleSens = sens.getSensitivity(curveName, GBP);
assertEquals(singleSens.Sensitivity, DoubleArray.of(3, 4, 5));
assertEquals(singleSens.getParameterMetadata(0), TENOR_MD_1W);
assertEquals(singleSens.getParameterMetadata(1), TENOR_MD_1M);
assertEquals(singleSens.getParameterMetadata(2), TENOR_MD_1Y);
}
public CurrencyParameterSensitivity singleDiscountCurveParameterSensitivity(PointSensitivities pointSensitivities, Currency currency)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is ZeroRateSensitivity)
{
ZeroRateSensitivity pt = (ZeroRateSensitivity)point;
if (pt.Currency.Equals(currency))
{
CreditDiscountFactors factors = discountFactors(pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
}
}
ArgChecker.isTrue(sens.size() == 1, "sensitivity must be unique");
return(sens.Sensitivities.get(0));
}
public CurrencyParameterSensitivity singleCreditCurveParameterSensitivity(PointSensitivities pointSensitivities, StandardId legalEntityId, Currency currency)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is CreditCurveZeroRateSensitivity)
{
CreditCurveZeroRateSensitivity pt = (CreditCurveZeroRateSensitivity)point;
if (pt.LegalEntityId.Equals(legalEntityId) && pt.Currency.Equals(currency))
{
LegalEntitySurvivalProbabilities factors = survivalProbabilities(pt.LegalEntityId, pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
}
}
ArgChecker.isTrue(sens.size() == 1, "sensitivity must be unique");
return(sens.Sensitivities.get(0));
}
public virtual void test_parameterSensitivity_inverse()
{
for (int i = 0; i < NB_EXPIRY; i++)
{
for (int j = 0; j < NB_STRIKE; ++j)
{
double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]);
FxOptionSensitivity sensi = FxOptionSensitivity.of(VOLS.Name, CURRENCY_PAIR.inverse(), timeToExpiry, 1d / TEST_STRIKE[j], 1d / FORWARD[i], GBP, 1d);
CurrencyParameterSensitivities computed = VOLS.parameterSensitivity(sensi);
for (int k = 0; k < TIMES.size(); k++)
{
double value = computed.Sensitivities.get(0).Sensitivity.get(k);
double nodeExpiry = TIMES.get(k);
double expected = nodeSensitivity(VOLS, CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i], nodeExpiry);
assertEquals(value, expected, EPS);
}
}
}
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sensitivity_credit_isda()
public virtual void sensitivity_credit_isda()
{
LocalDate valuationDate = LocalDate.of(2014, 1, 3);
CreditRatesProvider rates = CreditRatesProviderDataSets.createCreditRatesProvider(valuationDate);
CurrencyParameterSensitivities sensiComputed = FD_CALCULATOR.sensitivity(rates, this.creditFunction);
IList <IsdaCreditDiscountFactors> curves = CreditRatesProviderDataSets.getAllDiscountFactors(valuationDate);
assertEquals(sensiComputed.size(), curves.Count);
foreach (IsdaCreditDiscountFactors curve in curves)
{
DoubleArray time = curve.ParameterKeys;
DoubleArray sensiValueComputed = sensiComputed.getSensitivity(curve.Curve.Name, USD).Sensitivity;
assertEquals(sensiValueComputed.size(), time.size());
for (int i = 0; i < time.size(); i++)
{
assertEquals(time.get(i), sensiValueComputed.get(i), TOLERANCE_DELTA);
}
}
}
// computes the sensitivity with respect to the curves
private CurrencyParameterSensitivities sensitivity <T>(ImmutableRatesProvider provider, IDictionary <T, Curve> baseCurves, System.Func <ImmutableRatesProvider, IDictionary <T, Curve>, ImmutableRatesProvider> storeBumpedFn, System.Func <ImmutableRatesProvider, CurrencyAmount> valueFn, CurrencyAmount valueInit)
{
CurrencyParameterSensitivities result = CurrencyParameterSensitivities.empty();
foreach (KeyValuePair <T, Curve> entry in baseCurves.SetOfKeyValuePairs())
{
Curve curve = entry.Value;
DoubleArray sensitivity = DoubleArray.of(curve.ParameterCount, i =>
{
Curve dscBumped = curve.withParameter(i, curve.getParameter(i) + shift);
IDictionary <T, Curve> mapBumped = new Dictionary <T, Curve>(baseCurves);
mapBumped[entry.Key] = dscBumped;
ImmutableRatesProvider providerDscBumped = storeBumpedFn(provider, mapBumped);
return((valueFn(providerDscBumped).Amount - valueInit.Amount) / shift);
});
result = result.combinedWith(curve.createParameterSensitivity(valueInit.Currency, sensitivity));
}
return(result);
}
public virtual void test_presentValueSensitivityRatesStickyModel_stickyStrike()
{
SwaptionVolatilities volSabr = SwaptionSabrRateVolatilityDataSet.getVolatilitiesUsd(VAL_DATE, false);
double impliedVol = SWAPTION_PRICER.impliedVolatility(SWAPTION_REC_LONG, RATE_PROVIDER, volSabr);
SurfaceMetadata blackMeta = Surfaces.blackVolatilityByExpiryTenor("CST", VOLS.DayCount);
SwaptionVolatilities volCst = BlackSwaptionExpiryTenorVolatilities.of(VOLS.Convention, VOLS.ValuationDateTime, ConstantSurface.of(blackMeta, impliedVol));
// To obtain a constant volatility surface which create a sticky strike sensitivity
PointSensitivityBuilder pointRec = SWAPTION_PRICER.presentValueSensitivityRatesStickyStrike(SWAPTION_REC_LONG, RATE_PROVIDER, volSabr);
CurrencyParameterSensitivities computedRec = RATE_PROVIDER.parameterSensitivity(pointRec.build());
CurrencyParameterSensitivities expectedRec = FD_CAL.sensitivity(RATE_PROVIDER, (p) => SWAPTION_PRICER.presentValue(SWAPTION_REC_LONG, (p), volCst));
assertTrue(computedRec.equalWithTolerance(expectedRec, NOTIONAL * FD_EPS * 100d));
PointSensitivityBuilder pointPay = SWAPTION_PRICER.presentValueSensitivityRatesStickyStrike(SWAPTION_PAY_SHORT, RATE_PROVIDER, volSabr);
CurrencyParameterSensitivities computedPay = RATE_PROVIDER.parameterSensitivity(pointPay.build());
CurrencyParameterSensitivities expectedPay = FD_CAL.sensitivity(RATE_PROVIDER, (p) => SWAPTION_PRICER.presentValue(SWAPTION_PAY_SHORT, (p), volCst));
assertTrue(computedPay.equalWithTolerance(expectedPay, NOTIONAL * FD_EPS * 100d));
}
//-------------------------------------------------------------------------
private void testSurfaceParameterSensitivities(CurrencyParameterSensitivities computed, CurrencyParameterSensitivities expected, double tol)
{
IList <CurrencyParameterSensitivity> listComputed = new List <CurrencyParameterSensitivity>(computed.Sensitivities);
IList <CurrencyParameterSensitivity> listExpected = new List <CurrencyParameterSensitivity>(expected.Sensitivities);
foreach (CurrencyParameterSensitivity sensExpected in listExpected)
{
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
int index = Math.Abs(Collections.binarySearch(listComputed, sensExpected, CurrencyParameterSensitivity::compareKey));
CurrencyParameterSensitivity sensComputed = listComputed[index];
int nSens = sensExpected.ParameterCount;
assertEquals(sensComputed.ParameterCount, nSens);
for (int i = 0; i < nSens; ++i)
{
assertEquals(sensComputed.Sensitivity.get(i), sensExpected.Sensitivity.get(i), tol);
}
listComputed.RemoveAt(index);
}
}
public virtual void test_builder_mixCurrency()
{
CurveName curveName = CurveName.of("WEIRD");
CurveSensitivities test = CurveSensitivities.builder(PortfolioItemInfo.empty()).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1Y, 1).add(ZERO_RATE_DELTA, curveName, USD, TENOR_MD_1Y, 2).build();
assertEquals(test.Info, PortfolioItemInfo.empty());
assertEquals(test.TypedSensitivities.size(), 1);
CurrencyParameterSensitivities sens = test.getTypedSensitivity(ZERO_RATE_DELTA);
assertEquals(sens.Sensitivities.size(), 2);
CurrencyParameterSensitivity sensGbp = sens.getSensitivity(curveName, GBP);
assertEquals(sensGbp.Sensitivity, DoubleArray.of(1));
assertEquals(sensGbp.getParameterMetadata(0), TENOR_MD_1Y);
CurrencyParameterSensitivity sensUsd = sens.getSensitivity(curveName, USD);
assertEquals(sensUsd.Sensitivity, DoubleArray.of(2));
assertEquals(sensUsd.getParameterMetadata(0), TENOR_MD_1Y);
}
