//------------------------------------------------------------------------- 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); }