public virtual void test_rateSensitivity()
{
IborIndexRates mockIbor = mock(typeof(IborIndexRates));
SimpleRatesProvider prov = new SimpleRatesProvider();
prov.IborRates = mockIbor;
IList <IborAveragedFixing> fixings = new List <IborAveragedFixing>();
double totalWeight = 0.0d;
for (int i = 0; i < OBSERVATIONS.Length; i++)
{
IborIndexObservation obs = OBSERVATIONS[i];
IborAveragedFixing fixing = IborAveragedFixing.builder().observation(obs).weight(WEIGHTS[i]).build();
fixings.Add(fixing);
totalWeight += WEIGHTS[i];
when(mockIbor.ratePointSensitivity(obs)).thenReturn(SENSITIVITIES[i]);
}
PointSensitivities expected = PointSensitivities.of(ImmutableList.of(IborRateSensitivity.of(OBSERVATIONS[0], WEIGHTS[0] / totalWeight), IborRateSensitivity.of(OBSERVATIONS[1], WEIGHTS[1] / totalWeight), IborRateSensitivity.of(OBSERVATIONS[2], WEIGHTS[2] / totalWeight), IborRateSensitivity.of(OBSERVATIONS[3], WEIGHTS[3] / totalWeight)));
IborAveragedRateComputation ro = IborAveragedRateComputation.of(fixings);
ForwardIborAveragedRateComputationFn obsFn = ForwardIborAveragedRateComputationFn.DEFAULT;
PointSensitivityBuilder test = obsFn.rateSensitivity(ro, ACCRUAL_START_DATE, ACCRUAL_END_DATE, prov);
assertEquals(test.build(), expected);
}
//-------------------------------------------------------------------------
// creates a simple provider
private SimpleRatesProvider createProvider(ResolvedFra fraExp)
{
DiscountFactors mockDf = SimpleDiscountFactors.of(GBP, VAL_DATE, ConstantCurve.of(Curves.discountFactors("DSC", DAY_COUNT), DISCOUNT_FACTOR));
LocalDateDoubleTimeSeries timeSeries = LocalDateDoubleTimeSeries.of(VAL_DATE, FORWARD_RATE);
IborIndexRates mockIbor = SimpleIborIndexRates.of(GBP_LIBOR_3M, VAL_DATE, ConstantCurve.of(Curves.forwardRates("L3M", DAY_COUNT), FORWARD_RATE), timeSeries);
SimpleRatesProvider prov = new SimpleRatesProvider(VAL_DATE, mockDf);
prov.IborRates = mockIbor;
return prov;
}
public virtual void test_rateSensitivity_finiteDifference()
{
IborIndexRates mockIbor = mock(typeof(IborIndexRates));
SimpleRatesProvider prov = new SimpleRatesProvider();
prov.IborRates = mockIbor;
double eps = 1.0e-7;
int nDates = OBSERVATIONS.Length;
IList <IborAveragedFixing> fixings = new List <IborAveragedFixing>();
for (int i = 0; i < nDates; i++)
{
IborIndexObservation obs = OBSERVATIONS[i];
IborAveragedFixing fixing = IborAveragedFixing.builder().observation(obs).weight(WEIGHTS[i]).build();
fixings.Add(fixing);
when(mockIbor.ratePointSensitivity(obs)).thenReturn(SENSITIVITIES[i]);
}
IborAveragedRateComputation ro = IborAveragedRateComputation.of(fixings);
ForwardIborAveragedRateComputationFn obsFn = ForwardIborAveragedRateComputationFn.DEFAULT;
PointSensitivityBuilder test = obsFn.rateSensitivity(ro, ACCRUAL_START_DATE, ACCRUAL_END_DATE, prov);
for (int i = 0; i < nDates; ++i)
{
IborIndexRates mockIborUp = mock(typeof(IborIndexRates));
SimpleRatesProvider provUp = new SimpleRatesProvider();
provUp.IborRates = mockIborUp;
IborIndexRates mockIborDw = mock(typeof(IborIndexRates));
SimpleRatesProvider provDw = new SimpleRatesProvider();
provDw.IborRates = mockIborDw;
for (int j = 0; j < nDates; ++j)
{
if (i == j)
{
when(mockIborUp.rate(OBSERVATIONS[j])).thenReturn(FIXING_VALUES[j] + eps);
when(mockIborDw.rate(OBSERVATIONS[j])).thenReturn(FIXING_VALUES[j] - eps);
}
else
{
when(mockIborUp.rate(OBSERVATIONS[j])).thenReturn(FIXING_VALUES[j]);
when(mockIborDw.rate(OBSERVATIONS[j])).thenReturn(FIXING_VALUES[j]);
}
}
double rateUp = obsFn.rate(ro, ACCRUAL_START_DATE, ACCRUAL_END_DATE, provUp);
double rateDw = obsFn.rate(ro, ACCRUAL_START_DATE, ACCRUAL_END_DATE, provDw);
double resExpected = 0.5 * (rateUp - rateDw) / eps;
assertEquals(test.build().Sensitivities.get(i).Sensitivity, resExpected, eps);
}
}
public virtual void merge_content_2()
{
ImmutableRatesProvider test1 = ImmutableRatesProvider.builder(VAL_DATE).discountCurve(GBP, DISCOUNT_CURVE_GBP).timeSeries(GBP_USD_WM, TS).build();
ImmutableRatesProvider test2 = ImmutableRatesProvider.builder(VAL_DATE).discountCurve(USD, DISCOUNT_CURVE_USD).iborIndexCurve(USD_LIBOR_3M, USD_LIBOR_CURVE).overnightIndexCurve(USD_FED_FUND, FED_FUND_CURVE).priceIndexCurve(GB_RPI, GBPRI_CURVE).timeSeries(GB_RPI, TS).build();
ImmutableRatesProvider merged = ImmutableRatesProvider.combined(FX_MATRIX, test1, test2);
assertEquals(merged.ValuationDate, VAL_DATE);
assertEquals(merged.discountFactors(USD), DiscountFactors.of(USD, VAL_DATE, DISCOUNT_CURVE_USD));
assertEquals(merged.discountFactors(GBP), DiscountFactors.of(GBP, VAL_DATE, DISCOUNT_CURVE_GBP));
assertEquals(merged.iborIndexRates(USD_LIBOR_3M), IborIndexRates.of(USD_LIBOR_3M, VAL_DATE, USD_LIBOR_CURVE));
assertEquals(merged.overnightIndexRates(USD_FED_FUND), OvernightIndexRates.of(USD_FED_FUND, VAL_DATE, FED_FUND_CURVE));
assertEquals(merged.priceIndexValues(GB_RPI), PriceIndexValues.of(GB_RPI, VAL_DATE, GBPRI_CURVE, TS));
assertEquals(merged.timeSeries(GBP_USD_WM), TS);
assertEquals(merged.FxRateProvider, FX_MATRIX);
}
/* Check calibration for forward curve directly interpolated on forward rates. */
public virtual void calibration_present_value_simple_forward()
{
InterpolatedNodalCurveDefinition dsc = InterpolatedNodalCurveDefinition.builder().name(DSCON_CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(CURVE_DC).interpolator(INTERPOLATOR_LINEAR).extrapolatorLeft(EXTRAPOLATOR_FLAT).extrapolatorRight(EXTRAPOLATOR_FLAT).nodes(DSC_NODES).build();
InterpolatedNodalCurveDefinition fwd = InterpolatedNodalCurveDefinition.builder().name(FWD3_CURVE_NAME).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.FORWARD_RATE).dayCount(CURVE_DC).interpolator(INTERPOLATOR_LINEAR).extrapolatorLeft(EXTRAPOLATOR_FLAT).extrapolatorRight(EXTRAPOLATOR_FLAT).nodes(FWD3_NODES).build();
RatesCurveGroupDefinition config = RatesCurveGroupDefinition.builder().name(CURVE_GROUP_NAME).addCurve(dsc, USD, USD_FED_FUND).addForwardCurve(fwd, USD_LIBOR_3M).build();
RatesProvider result = CALIBRATOR.calibrate(config, ALL_QUOTES_BD, REF_DATA);
assertResult(result, ALL_QUOTES_BD);
IborIndexRates ibor3M = result.iborIndexRates(USD_LIBOR_3M);
assertTrue(ibor3M is SimpleIborIndexRates, "USD-LIBOR-3M curve should be simple interpolation on forward rates");
double shift = 1.0E-6;
System.Func <MarketData, RatesProvider> f = marketData => CALIBRATOR.calibrate(config, marketData, REF_DATA);
calibration_market_quote_sensitivity_check(f, config, shift, TS_EMPTY);
}
//-------------------------------------------------------------------------
public virtual void test_of_withoutFixings()
{
SimpleIborIndexRates test = SimpleIborIndexRates.of(GBP_LIBOR_3M, DATE_VAL, CURVE);
assertEquals(test.Index, GBP_LIBOR_3M);
assertEquals(test.ValuationDate, DATE_VAL);
assertEquals(test.Fixings, SERIES_EMPTY);
assertEquals(test.Curve, CURVE);
assertEquals(test.ParameterCount, CURVE.ParameterCount);
assertEquals(test.getParameter(0), CURVE.getParameter(0));
assertEquals(test.getParameterMetadata(0), CURVE.getParameterMetadata(0));
assertEquals(test.withParameter(0, 1d).Curve, CURVE.withParameter(0, 1d));
assertEquals(test.withPerturbation((i, v, m) => v + 1d).Curve, CURVE.withPerturbation((i, v, m) => v + 1d));
assertEquals(test.findData(CURVE.Name), CURVE);
assertEquals(test.findData(CurveName.of("Rubbish")), null);
// check IborIndexRates
IborIndexRates test2 = IborIndexRates.of(GBP_LIBOR_3M, DATE_VAL, CURVE);
assertEquals(test, test2);
}
public SimpleRatesProvider(LocalDate valuationDate, DiscountFactors discountFactors, IborIndexRates iborRates)
{
this.valuationDate = valuationDate;
this.discountFactors_Renamed = discountFactors;
this.iborRates = iborRates;
}
