//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
double rate = 1.4d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(EUR, USD), rate);
FxForwardSensitivity test1 = (FxForwardSensitivity) @base.convertedTo(USD, matrix);
FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, USD, SENSITIVITY * rate);
assertEquals(test1, expected);
FxForwardSensitivity test2 = (FxForwardSensitivity) @base.convertedTo(EUR, matrix);
assertEquals(test2, @base);
}
public virtual void test_convertedTo_noConversion()
{
CashFlow @base = CashFlow.ofForecastValue(PAYMENT_DATE, GBP, FORECAST_VALUE, DISCOUNT_FACTOR);
CashFlow test = @base.convertedTo(GBP, FxMatrix.empty());
assertThat(test.PaymentDate).isEqualTo(PAYMENT_DATE);
assertThat(test.PresentValue).hasCurrency(GBP);
assertThat(test.PresentValue).hasAmount(PRESENT_VALUE, TOLERANCE);
assertThat(test.ForecastValue).hasCurrency(GBP);
assertThat(test.ForecastValue).hasAmount(FORECAST_VALUE, TOLERANCE);
assertThat(test.DiscountFactor).isCloseTo(DISCOUNT_FACTOR, TOLERANCE);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
BondFutureOptionSensitivity @base = BondFutureOptionSensitivity.of(NAME, OPTION_EXPIRY, FUTURE_EXPIRY, STRIKE_PRICE, FUTURE_PRICE, GBP, SENSITIVITY);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
BondFutureOptionSensitivity test1 = (BondFutureOptionSensitivity)@base.convertedTo(USD, matrix);
BondFutureOptionSensitivity expected = BondFutureOptionSensitivity.of(NAME, OPTION_EXPIRY, FUTURE_EXPIRY, STRIKE_PRICE, FUTURE_PRICE, USD, SENSITIVITY * rate);
assertEquals(test1, expected);
BondFutureOptionSensitivity test2 = (BondFutureOptionSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
FxIndexSensitivity @base = FxIndexSensitivity.of(GBP_USD_WM_OBS, GBP, SENSITIVITY_VALUE);
double rate = 1.35d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(EUR, USD), rate);
FxIndexSensitivity test1 = (FxIndexSensitivity)@base.convertedTo(EUR, matrix);
FxIndexSensitivity expected = FxIndexSensitivity.of(GBP_USD_WM_OBS, GBP, EUR, SENSITIVITY_VALUE / rate);
assertEquals(test1, expected);
FxIndexSensitivity test2 = (FxIndexSensitivity)@base.convertedTo(USD, matrix);
assertEquals(test2, @base);
}
public virtual void test_convertedTo()
{
IssuerCurveZeroRateSensitivity @base = IssuerCurveZeroRateSensitivity.of(CURRENCY, YEARFRAC, GROUP, VALUE);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IssuerCurveZeroRateSensitivity test1 = @base.convertedTo(USD, matrix);
assertEquals(test1, @base);
IssuerCurveZeroRateSensitivity test2 = @base.convertedTo(GBP, matrix);
IssuerCurveZeroRateSensitivity expected = IssuerCurveZeroRateSensitivity.of(CURRENCY, YEARFRAC, GBP, GROUP, VALUE / rate);
assertEquals(test2, expected);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
IborCapletFloorletSensitivity @base = IborCapletFloorletSensitivity.of(NAME, EXPIRY, STRIKE, FORWARD, GBP, SENSITIVITY);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IborCapletFloorletSensitivity test1 = @base.convertedTo(USD, matrix);
IborCapletFloorletSensitivity expected = IborCapletFloorletSensitivity.of(NAME, EXPIRY, STRIKE, FORWARD, USD, SENSITIVITY * rate);
assertEquals(test1, expected);
IborCapletFloorletSensitivity test2 = @base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
IborRateSensitivity @base = IborRateSensitivity.of(GBP_LIBOR_3M_OBSERVATION, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IborRateSensitivity test1 = (IborRateSensitivity)@base.convertedTo(USD, matrix);
IborRateSensitivity expected = IborRateSensitivity.of(GBP_LIBOR_3M_OBSERVATION, USD, sensi * rate);
assertEquals(test1, expected);
IborRateSensitivity test2 = (IborRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
CreditCurveZeroRateSensitivity test1 = @base.convertedTo(USD, matrix);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, USD, rate * sensi);
assertEquals(test1, expected);
CreditCurveZeroRateSensitivity test2 = @base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
InflationRateSensitivity @base = InflationRateSensitivity.of(GB_HICP_OBS, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
InflationRateSensitivity test1 = (InflationRateSensitivity)@base.convertedTo(USD, matrix);
InflationRateSensitivity expected = InflationRateSensitivity.of(GB_HICP_OBS, USD, sensi * rate);
assertEquals(test1, expected);
InflationRateSensitivity test2 = (InflationRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
ZeroRateSensitivity @base = ZeroRateSensitivity.of(GBP, YEARFRAC, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
ZeroRateSensitivity test1 = (ZeroRateSensitivity)@base.convertedTo(USD, matrix);
ZeroRateSensitivity expected = ZeroRateSensitivity.of(GBP, YEARFRAC, USD, rate * sensi);
assertEquals(test1, expected);
ZeroRateSensitivity test2 = (ZeroRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
LocalDate fixingDate = DATE;
LocalDate endDate = date(2015, 10, 27);
double sensi = 32d;
OvernightRateSensitivity @base = OvernightRateSensitivity.ofPeriod(OvernightIndexObservation.of(GBP_SONIA, fixingDate, REF_DATA), endDate, GBP, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
OvernightRateSensitivity test1 = (OvernightRateSensitivity)@base.convertedTo(USD, matrix);
OvernightRateSensitivity expected = OvernightRateSensitivity.ofPeriod(OvernightIndexObservation.of(GBP_SONIA, fixingDate, REF_DATA), endDate, USD, rate * sensi);
assertEquals(test1, expected);
OvernightRateSensitivity test2 = (OvernightRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo_singleCurrency()
{
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
PointSensitivities @base = PointSensitivities.of(Lists.newArrayList(CS3, CS2, CS1));
PointSensitivities test1 = @base.convertedTo(USD, matrix);
PointSensitivity c1Conv = CS1.convertedTo(USD, matrix);
PointSensitivity c2Conv = CS2.convertedTo(USD, matrix);
PointSensitivity c3Conv = CS3.convertedTo(USD, matrix);
PointSensitivities expected = PointSensitivities.of(Lists.newArrayList(c3Conv, c2Conv, c1Conv));
assertEquals(test1.normalized(), expected.normalized());
PointSensitivities test2 = @base.convertedTo(GBP, matrix);
assertEquals(test2.normalized(), @base.normalized());
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
LocalDate fixingDate = date(2015, 8, 28);
double strike = 0.98d;
double forward = 0.99d;
double sensi = 32d;
IborFutureOptionSensitivity @base = IborFutureOptionSensitivity.of(NAME, 12d, fixingDate, strike, forward, GBP, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IborFutureOptionSensitivity test1 = (IborFutureOptionSensitivity)@base.convertedTo(USD, matrix);
IborFutureOptionSensitivity expected = IborFutureOptionSensitivity.of(NAME, 12d, fixingDate, strike, forward, USD, sensi * rate);
assertEquals(test1, expected);
IborFutureOptionSensitivity test2 = (IborFutureOptionSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
public virtual void test_convertedTo_multipleCurrency()
{
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
PointSensitivities @base = PointSensitivities.of(Lists.newArrayList(CS4, CS3, CS1));
PointSensitivities test1 = @base.convertedTo(USD, matrix);
PointSensitivity c1Conv = CS1.convertedTo(USD, matrix);
PointSensitivity c3Conv = CS3.convertedTo(USD, matrix);
PointSensitivity c3c4Usd = c3Conv.withSensitivity(c3Conv.Sensitivity + CS4.Sensitivity);
PointSensitivities expected1 = PointSensitivities.of(Lists.newArrayList(c3c4Usd, c1Conv));
assertEquals(test1.normalized(), expected1.normalized());
PointSensitivities test2 = @base.convertedTo(GBP, matrix);
PointSensitivity c4Conv = CS4.convertedTo(GBP, matrix);
PointSensitivity c3c4GBP = CS3.withSensitivity(CS3.Sensitivity + c4Conv.Sensitivity);
PointSensitivities expected2 = PointSensitivities.of(Lists.newArrayList(c3c4GBP, CS1));
assertEquals(test2.normalized(), expected2.normalized());
}
/// <summary>
/// Creates rates provider with specified valuation date.
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <returns> the rates provider </returns>
public static ImmutableRatesProvider createRatesProvider(LocalDate valuationDate)
{
return(ImmutableRatesProvider.builder(valuationDate).discountCurves(ImmutableMap.of(EUR, DSC_CURVE)).indexCurves(ImmutableMap.of(EUR_EURIBOR_3M, FWD3_CURVE, EUR_EURIBOR_6M, FWD6_CURVE)).fxRateProvider(FxMatrix.empty()).build());
}
/// <summary>
/// Creates rates provider for EUR, USD with FX matrix.
/// <para>
/// The discount curves are flat.
///
/// </para>
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <returns> the rates provider </returns>
public static ImmutableRatesProvider createProviderEurUsdFlat(LocalDate valuationDate)
{
FxMatrix fxMatrix = FxMatrix.builder().addRate(USD, EUR, 1.0d / EUR_USD).build();
return(ImmutableRatesProvider.builder(valuationDate).discountCurve(EUR, EUR_DSC_FLAT).discountCurve(USD, USD_DSC_FLAT).fxRateProvider(fxMatrix).build());
}
/// <summary>
/// Obtains an immutable rates providers with valuation date and time series.
/// <para>
/// The time series must contain historical data for the price index.
///
/// </para>
/// </summary>
/// <param name="valuationDate"> the valuation date </param>
/// <param name="timeSeries"> the time series </param>
/// <returns> the rates provider </returns>
public static ImmutableRatesProvider getRatesProvider(LocalDate valuationDate, LocalDateDoubleTimeSeries timeSeries)
{
return(ImmutableRatesProvider.builder(valuationDate).fxRateProvider(FxMatrix.empty()).priceIndexCurve(US_CPI_U, CPI_CURVE).timeSeries(US_CPI_U, timeSeries).build());
}
public virtual void test_convertedTo_empty()
{
assertEquals(PointSensitivities.empty().convertedTo(GBP, FxMatrix.empty()), PointSensitivities.empty());
}
public virtual void test_ofMatrix_source()
{
FxRateLookup test = FxRateLookup.ofMatrix(FxMatrixId.of(OBS_SOURCE));
MarketData marketData = ImmutableMarketData.builder(VAL_DATE).addValue(FxMatrixId.of(OBS_SOURCE), FxMatrix.of(GBP, USD, 1.5d)).build();
assertEquals(test.fxRateProvider(marketData).fxRate(GBP, USD), 1.5d);
}
