public virtual void test_rate() { SimpleRatesProvider prov = new SimpleRatesProvider(); LocalDateDoubleTimeSeries timeSeries = LocalDateDoubleTimeSeries.of(FIXING_DATE, RATE); IborIndexRates mockIbor = new TestingIborIndexRates(GBP_LIBOR_3M, FIXING_DATE, LocalDateDoubleTimeSeries.empty(), timeSeries); prov.IborRates = mockIbor; ForwardIborRateComputationFn obsFn = ForwardIborRateComputationFn.DEFAULT; assertEquals(obsFn.rate(GBP_LIBOR_3M_COMP, ACCRUAL_START_DATE, ACCRUAL_END_DATE, prov), RATE); // explain ExplainMapBuilder builder = ExplainMap.builder(); assertEquals(obsFn.explainRate(GBP_LIBOR_3M_COMP, ACCRUAL_START_DATE, ACCRUAL_END_DATE, prov, builder), RATE); ExplainMap built = builder.build(); assertEquals(built.get(ExplainKey.OBSERVATIONS).Present, true); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().size(), 1); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().get(0).get(ExplainKey.FIXING_DATE), FIXING_DATE); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().get(0).get(ExplainKey.INDEX), GBP_LIBOR_3M); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().get(0).get(ExplainKey.INDEX_VALUE), RATE); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().get(0).get(ExplainKey.FROM_FIXING_SERIES), true); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().get(0).get(ExplainKey.FORWARD_RATE_START_DATE), FORWARD_START_DATE); assertEquals(built.get(ExplainKey.OBSERVATIONS).get().get(0).get(ExplainKey.FORWARD_RATE_END_DATE), FORWARD_END_DATE); assertEquals(built.get(ExplainKey.COMBINED_RATE), RATE); }
public virtual void test_presentValue_ended() { SimpleRatesProvider prov = provider(date(2014, 9, 22), 1.2d, 1.1d); CurrencyAmount computed = PRICER.presentValue(RTERM_DEPOSIT, prov); assertEquals(computed.Currency, EUR); assertEquals(computed.Amount, 0.0d, TOLERANCE * NOTIONAL); }
public virtual void test_presentValue_inPast() { SimpleRatesProvider prov = createProvider(VAL_DATE); double pvComputed = PRICER.presentValue(PERIOD_PAST, prov); assertEquals(pvComputed, 0, TOLERANCE_PV); }
public virtual void test_accruedInterest_valDateAfterPeriod() { SimpleRatesProvider prov = createProvider(PERIOD.EndDate.plusDays(1)); double computed = PRICER.accruedInterest(PERIOD, prov); assertEquals(computed, 0, TOLERANCE_PV); }
public virtual void test_accruedInterest_valDateBeforePeriod() { SimpleRatesProvider prov = createProvider(PERIOD.StartDate); double computed = PRICER.accruedInterest(PERIOD, prov); assertEquals(computed, 0, TOLERANCE_PV); }
public virtual void test_presentValueSensitivity_inPast() { SimpleRatesProvider prov = createProvider(VAL_DATE); PointSensitivities computed = PRICER.presentValueSensitivity(PERIOD_PAST, prov).build(); assertEquals(computed, PointSensitivities.empty()); }
public virtual void test_parSpread() { SimpleRatesProvider prov = provider(VAL_DATE, DF_START, DF_END); double parSpread = PRICER.parSpread(RTERM_DEPOSIT, prov); TermDeposit depositPar = TermDeposit.builder().buySell(BuySell.BUY).startDate(START_DATE).endDate(END_DATE).businessDayAdjustment(BD_ADJ).dayCount(ACT_360).notional(NOTIONAL).currency(EUR).rate(RATE + parSpread).build(); double pvPar = PRICER.presentValue(depositPar.resolve(REF_DATA), prov).Amount; assertEquals(pvPar, 0.0, NOTIONAL * TOLERANCE); }
public virtual void test_presentValue_onStart() { SimpleRatesProvider prov = provider(START_DATE, 1.0d, DF_END); CurrencyAmount computed = PRICER.presentValue(RTERM_DEPOSIT, prov); double expected = ((1d + RATE * RTERM_DEPOSIT.YearFraction) * DF_END - 1.0d) * NOTIONAL; assertEquals(computed.Currency, EUR); assertEquals(computed.Amount, expected, TOLERANCE * NOTIONAL); }
//------------------------------------------------------------------------- public virtual void test_forecastValue() { SimpleRatesProvider prov = createProvider(VAL_DATE); double fvExpected = AMOUNT_1000; double fvComputed = PRICER.forecastValue(PERIOD, prov); assertEquals(fvComputed, fvExpected, TOLERANCE_PV); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { SimpleRatesProvider prov = createProvider(VAL_DATE); double pvExpected = AMOUNT_1000 * DISCOUNT_FACTOR; double pvComputed = PRICER.presentValue(PERIOD, prov); assertEquals(pvComputed, pvExpected, TOLERANCE_PV); }
public virtual void test_presentValue_started() { SimpleRatesProvider prov = provider(date(2014, 2, 22), 1.2d, DF_END); CurrencyAmount computed = PRICER.presentValue(RTERM_DEPOSIT, prov); double expected = (1d + RATE * RTERM_DEPOSIT.YearFraction) * DF_END * NOTIONAL; assertEquals(computed.Currency, EUR); assertEquals(computed.Amount, expected, TOLERANCE * NOTIONAL); }
//------------------------------------------------------------------------- public virtual void test_price() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(FUTURE.IborRate.Observation)).thenReturn(RATE); assertEquals(PRICER_TRADE.price(FUTURE_TRADE, prov), 1.0 - RATE, TOLERANCE_PRICE); }
//------------------------------------------------------------------------- // creates a simple provider private SimpleRatesProvider createProvider(LocalDate valDate) { Curve curve = ConstantCurve.of(Curves.discountFactors("Test", DAY_COUNT), DISCOUNT_FACTOR); DiscountFactors df = SimpleDiscountFactors.of(GBP, valDate, curve); SimpleRatesProvider prov = new SimpleRatesProvider(valDate); prov.DayCount = DAY_COUNT; prov.DiscountFactors = df; return(prov); }
//------------------------------------------------------------------------- public virtual void test_accruedInterest() { LocalDate valDate = PERIOD.StartDate.plusDays(7); SimpleRatesProvider prov = createProvider(valDate); double expected = AMOUNT_1000 * (7d / (7 + 28 + 31 + 25)); double computed = PRICER.accruedInterest(PERIOD, prov); assertEquals(computed, expected, TOLERANCE_PV); }
private SimpleRatesProvider provider(LocalDate valuationDate, double dfStart, double dfEnd) { DiscountFactors mockDf = mock(typeof(DiscountFactors)); when(mockDf.discountFactor(START_DATE)).thenReturn(dfStart); when(mockDf.discountFactor(END_DATE)).thenReturn(dfEnd); SimpleRatesProvider prov = new SimpleRatesProvider(valuationDate, mockDf); return(prov); }
//------------------------------------------------------------------------- public virtual void test_priceSensitivity() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; PointSensitivities sensiExpected = PointSensitivities.of(IborRateSensitivity.of(FUTURE.IborRate.Observation, -1d)); PointSensitivities sensiComputed = PRICER.priceSensitivity(FUTURE, prov); assertTrue(sensiComputed.equalWithTolerance(sensiExpected, TOLERANCE_PRICE_DELTA)); }
//------------------------------------------------------------------------- public virtual void test_parSpreadSensitivity() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; PointSensitivities sensiExpected = PRICER_PRODUCT.priceSensitivity(FUTURE, prov); PointSensitivities sensiComputed = PRICER_TRADE.parSpreadSensitivity(FUTURE_TRADE, prov); assertTrue(sensiComputed.equalWithTolerance(sensiExpected, TOLERANCE_PRICE_DELTA)); }
//------------------------------------------------------------------------- public virtual void test_presentValueSensitivity() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; PointSensitivities sensiPrice = PRICER_PRODUCT.priceSensitivity(FUTURE, prov); PointSensitivities sensiPresentValueExpected = sensiPrice.multipliedBy(FUTURE.Notional * FUTURE.AccrualFactor * FUTURE_TRADE.Quantity); PointSensitivities sensiPresentValueComputed = PRICER_TRADE.presentValueSensitivity(FUTURE_TRADE, prov); assertTrue(sensiPresentValueComputed.equalWithTolerance(sensiPresentValueExpected, TOLERANCE_PV_DELTA)); }
public virtual void test_rateSensitivity() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.ratePointSensitivity(GBP_LIBOR_3M_COMP.Observation)).thenReturn(SENSITIVITY); ForwardIborRateComputationFn obsFn = ForwardIborRateComputationFn.DEFAULT; assertEquals(obsFn.rateSensitivity(GBP_LIBOR_3M_COMP, ACCRUAL_START_DATE, ACCRUAL_END_DATE, prov), SENSITIVITY); }
// ---------- present value sensitivity ---------- public virtual void presentValueSensitivity_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); PointSensitivities psProduct = OPTION_PRODUCT_PRICER.priceSensitivityRatesStickyStrike(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); PointSensitivities psExpected = psProduct.multipliedBy(OPTION_PRODUCT_PRICER.marginIndex(OPTION, 1) * OPTION_QUANTITY); PointSensitivities psComputed = OPTION_TRADE_PRICER.presentValueSensitivityRates(FUTURE_OPTION_TRADE, prov, VOL_SIMPLE_MONEY_PRICE); assertTrue(psComputed.equalWithTolerance(psExpected, TOLERANCE_PV_DELTA)); }
public virtual void price_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); double futurePrice = 1.0 - RATE; double optionPriceExpected = OPTION_PRICER.price(OPTION, prov, VOL_SIMPLE_MONEY_PRICE, futurePrice); double optionPriceComputed = OPTION_PRICER.price(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); assertEquals(optionPriceComputed, optionPriceExpected, TOLERANCE_PRICE); }
//------------------------------------------------------------------------- public virtual void test_parSpread_after_trade_date() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; prov.ValuationDate = FUTURE_TRADE.TradedPrice.get().TradeDate.plusDays(1); when(mockIbor.rate(FUTURE.IborRate.Observation)).thenReturn(RATE); double lastClosingPrice = 0.99; double parSpreadExpected = PRICER_TRADE.price(FUTURE_TRADE, prov) - lastClosingPrice; double parSpreadComputed = PRICER_TRADE.parSpread(FUTURE_TRADE, prov, lastClosingPrice); assertEquals(parSpreadComputed, parSpreadExpected, TOLERANCE_PRICE); }
static DiscountingFraTradePricerTest() { DiscountFactors mockDf = mock(typeof(DiscountFactors)); IborIndexRates mockIbor = mock(typeof(IborIndexRates)); RATES_PROVIDER = new SimpleRatesProvider(VAL_DATE, mockDf); RATES_PROVIDER.IborRates = mockIbor; IborIndexObservation obs = ((IborRateComputation)RFRA.FloatingRate).Observation; IborRateSensitivity sens = IborRateSensitivity.of(obs, 1d); when(mockIbor.ratePointSensitivity(obs)).thenReturn(sens); when(mockIbor.rate(obs)).thenReturn(FORWARD_RATE); when(mockDf.discountFactor(RFRA.PaymentDate)).thenReturn(DISCOUNT_FACTOR); }
//------------------------------------------------------------------------- public virtual void test_presentValueSensitivity() { SimpleRatesProvider prov = createProvider(VAL_DATE); PointSensitivities point = PRICER.presentValueSensitivity(PERIOD, prov).build(); double relativeYearFraction = DAY_COUNT.relativeYearFraction(VAL_DATE, PAYMENT_DATE); double expected = -DISCOUNT_FACTOR * relativeYearFraction * AMOUNT_1000; ZeroRateSensitivity actual = (ZeroRateSensitivity)point.Sensitivities.get(0); assertEquals(actual.Currency, GBP); assertEquals(actual.CurveCurrency, GBP); assertEquals(actual.YearFraction, relativeYearFraction); assertEquals(actual.Sensitivity, expected, AMOUNT_1000 * TOLERANCE_PV); }
public virtual void presentValue_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(VAL_DATE); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); double lastClosingPrice = 0.0150; CurrencyAmount pvComputed = OPTION_TRADE_PRICER.presentValue(FUTURE_OPTION_TRADE, prov, VOL_SIMPLE_MONEY_PRICE, lastClosingPrice); double optionPrice = OPTION_PRODUCT_PRICER.price(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); double pvExpected = (OPTION_PRODUCT_PRICER.marginIndex(OPTION, optionPrice) - OPTION_PRODUCT_PRICER.marginIndex(OPTION, lastClosingPrice)) * OPTION_QUANTITY; assertEquals(pvComputed.Amount, pvExpected, TOLERANCE_PV); }
// ---------- present value normal vol sensitivity ---------- public virtual void presentvalue_normalVolSensitivity_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); IborFutureOptionSensitivity psProduct = OPTION_PRODUCT_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); IborFutureOptionSensitivity psExpected = psProduct.withSensitivity(psProduct.Sensitivity * OPTION_PRODUCT_PRICER.marginIndex(OPTION, 1) * OPTION_QUANTITY); IborFutureOptionSensitivity psComputed = OPTION_TRADE_PRICER.presentValueSensitivityModelParamsVolatility(FUTURE_OPTION_TRADE, prov, VOL_SIMPLE_MONEY_PRICE); assertTrue(psExpected.compareKey(psComputed) == 0); assertEquals(psComputed.Sensitivity, psExpected.Sensitivity, TOLERANCE_PV_DELTA); }
public virtual void priceSensitivityStickyStrike_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); PointSensitivities futurePriceSensitivity = OPTION_PRICER.FuturePricer.priceSensitivity(OPTION.UnderlyingFuture, prov); double delta = OPTION_PRICER.deltaStickyStrike(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); PointSensitivities optionPriceSensitivityExpected = futurePriceSensitivity.multipliedBy(delta); PointSensitivities optionPriceSensitivityComputed = OPTION_PRICER.priceSensitivityRatesStickyStrike(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); assertTrue(optionPriceSensitivityExpected.equalWithTolerance(optionPriceSensitivityComputed, TOLERANCE_PRICE_DELTA)); }
public virtual void priceSensitivityNormalVolatility_from_env() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); double futurePrice = 1.0 - RATE; IborFutureOptionSensitivity optionVegaExpected = OPTION_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE, futurePrice); IborFutureOptionSensitivity optionVegaComputed = OPTION_PRICER.priceSensitivityModelParamsVolatility(OPTION, prov, VOL_SIMPLE_MONEY_PRICE); assertTrue(optionVegaExpected.compareKey(optionVegaComputed) == 0); assertEquals(optionVegaComputed.Sensitivity, optionVegaExpected.Sensitivity, TOLERANCE_PRICE_DELTA); }
public virtual void test_presentValue_on_trade_date() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; prov.ValuationDate = FUTURE_TRADE.TradedPrice.get().TradeDate; when(mockIbor.rate(FUTURE.IborRate.Observation)).thenReturn(RATE); double lastClosingPrice = 1.025; DiscountingIborFutureTradePricer pricerFn = DiscountingIborFutureTradePricer.DEFAULT; double expected = ((1.0 - RATE) - FUTURE_TRADE.TradedPrice.get().Price) * FUTURE.AccrualFactor * FUTURE.Notional * FUTURE_TRADE.Quantity; CurrencyAmount computed = pricerFn.presentValue(FUTURE_TRADE, prov, lastClosingPrice); assertEquals(computed.Amount, expected, TOLERANCE_PV); assertEquals(computed.Currency, FUTURE.Currency); }
// ---------- price ---------- public virtual void price_from_future_price() { IborIndexRates mockIbor = mock(typeof(IborIndexRates)); SimpleRatesProvider prov = new SimpleRatesProvider(); prov.IborRates = mockIbor; when(mockIbor.rate(OPTION.UnderlyingFuture.IborRate.Observation)).thenReturn(RATE); double futurePrice = 0.9875; double strike = OPTION.StrikePrice; double timeToExpiry = ACT_365F.relativeYearFraction(VAL_DATE, OPTION.ExpiryDate); double priceSimpleMoneyness = strike - futurePrice; double normalVol = PARAMETERS_PRICE.zValue(timeToExpiry, priceSimpleMoneyness); EuropeanVanillaOption option = EuropeanVanillaOption.of(strike, timeToExpiry, OPTION.PutCall); NormalFunctionData normalPoint = NormalFunctionData.of(futurePrice, 1.0, normalVol); double optionPriceExpected = NORMAL_FUNCTION.getPriceFunction(option).apply(normalPoint); double optionPriceComputed = OPTION_PRICER.price(OPTION, prov, VOL_SIMPLE_MONEY_PRICE, futurePrice); assertEquals(optionPriceComputed, optionPriceExpected, TOLERANCE_PRICE); }