@Override public double relativeTime(ZonedDateTime dateTime) { ArgChecker.notNull(dateTime, "dateTime"); LocalDate valuationDate = valuationDateTime.toLocalDate(); LocalDate date = dateTime.toLocalDate(); return dayCount.relativeYearFraction(valuationDate, date); }
@Override public double relativeTime(ZonedDateTime zonedDateTime) { ArgChecker.notNull(zonedDateTime, "date"); return dayCount.relativeYearFraction(valuationDateTime.toLocalDate(), zonedDateTime.toLocalDate()); }
/** * Computes the yield from the price at a given settlement date. * * @param price the price * @param settlementDate the settlement date * @return the yield */ public double yieldFromPrice(double price, LocalDate settlementDate) { double accrualFactor = dayCount.relativeYearFraction(settlementDate, notional.getDate()); return yieldConvention.yieldFromPrice(price, accrualFactor); }
public void test_futuresConvexityFactor() { HullWhiteOneFactorPiecewiseConstantParametersProvider provider = HullWhiteOneFactorPiecewiseConstantParametersProvider.of(PARAMETERS, ACT_360, DATE_TIME); LocalDate data1 = LocalDate.of(2015, 5, 14); LocalDate data2 = LocalDate.of(2015, 5, 20); LocalDate data3 = LocalDate.of(2015, 8, 20); double computed = provider.futuresConvexityFactor(data1, data2, data3); double expected = HullWhiteOneFactorPiecewiseConstantInterestRateModel.DEFAULT.futuresConvexityFactor(PARAMETERS, ACT_360.relativeYearFraction(VAL_DATE, data1), ACT_360.relativeYearFraction(VAL_DATE, data2), ACT_360.relativeYearFraction(VAL_DATE, data3)); assertEquals(computed, expected); }
public void test_currentCash_valuationAtMaturity_noExcoupon() { LocalDate startDate = LocalDate.of(2024, 10, 14); LocalDate paymentDate = LocalDate.of(2025, 4, 14); double yc = DAY_COUNT.relativeYearFraction(startDate, paymentDate); CurrencyAmount ccComputed = TRADE_PRICER.currentCash(TRADE_NO_EXCOUPON, paymentDate); assertEquals(ccComputed, CurrencyAmount.of(EUR, NOTIONAL * (1d + yc * FIXED_RATE) * QUANTITY)); }
public void test_zeroRate() { ZeroRateDiscountFactors test = ZeroRateDiscountFactors.of(GBP, DATE_VAL, CURVE); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double discountFactor = test.discountFactor(DATE_AFTER); double zeroRate = test.zeroRate(DATE_AFTER); assertEquals(Math.exp(-zeroRate * relativeYearFraction), discountFactor); }
public void test_discountFactorWithSpread_continuous() { ZeroRateDiscountFactors test = ZeroRateDiscountFactors.of(GBP, DATE_VAL, CURVE); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double expected = Math.exp(-relativeYearFraction * (CURVE.yValue(relativeYearFraction) + SPREAD)); assertEquals(test.discountFactorWithSpread(DATE_AFTER, SPREAD, CONTINUOUS, 0), expected, TOL); }
public void test_accruedInterest_jpw() { double accPositive = PRODUCT_JPW.accruedInterest(LocalDate.of(2016, 3, 9)); CapitalIndexedBondPaymentPeriod period = PRODUCT_JPW.getPeriodicPayments().get(4); double yc = PRODUCT_JPW.getDayCount().relativeYearFraction(period.getStartDate(), period.getEndDate()); double expected = CPN_VALUE_JPW * 2d * yc * NTNL; // accrual of total period based on ACT/365F assertEquals(accPositive, expected, NTNL * NOTIONAL); double accZero = PRODUCT_JPW.accruedInterest(LocalDate.of(2016, 3, 10)); assertEquals(accZero, 0d); }
public void test_zeroRatePointSensitivity() { ZeroRateDiscountFactors test = ZeroRateDiscountFactors.of(GBP, DATE_VAL, CURVE); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double df = Math.exp(-relativeYearFraction * CURVE.yValue(relativeYearFraction)); ZeroRateSensitivity expected = ZeroRateSensitivity.of(GBP, relativeYearFraction, -df * relativeYearFraction); assertEquals(test.zeroRatePointSensitivity(DATE_AFTER), expected); }
public void test_zeroRatePointSensitivityWithSpread_continuous() { SimpleDiscountFactors test = SimpleDiscountFactors.of(GBP, DATE_VAL, CURVE); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double df = CURVE.yValue(relativeYearFraction) * Math.exp(-SPREAD * relativeYearFraction); ZeroRateSensitivity expected = ZeroRateSensitivity.of(GBP, relativeYearFraction, -df * relativeYearFraction); assertEquals(test.zeroRatePointSensitivityWithSpread(DATE_AFTER, SPREAD, CONTINUOUS, 0), expected); }
public void test_accruedInterest_exCoupon_out() { LocalDate refDate = LocalDate.of(2014, 6, 10); CapitalIndexedBondPaymentPeriod period = PRODUCT_EX_COUPON.getPeriodicPayments().get(16); double computed = PRODUCT_EX_COUPON.accruedInterest(refDate); Schedule sch = SCHEDULE.createSchedule(REF_DATA).toUnadjusted(); double factor = ACT_ACT_ICMA.relativeYearFraction(period.getUnadjustedStartDate(), refDate, sch); assertEquals(computed, factor * REAL_COUPON_VALUE * NOTIONAL * 2d, TOL * REAL_COUPON_VALUE * NOTIONAL); }
private SimpleRatesProvider createProvider(NotionalExchange ne) { LocalDate paymentDate = ne.getPaymentDate(); double paymentTime = DAY_COUNT.relativeYearFraction(VAL_DATE, paymentDate); Currency currency = ne.getCurrency(); DiscountFactors mockDf = mock(DiscountFactors.class); when(mockDf.discountFactor(paymentDate)).thenReturn(DISCOUNT_FACTOR); ZeroRateSensitivity sens = ZeroRateSensitivity.of(currency, paymentTime, -DISCOUNT_FACTOR * paymentTime); when(mockDf.zeroRatePointSensitivity(paymentDate)).thenReturn(sens); SimpleRatesProvider prov = new SimpleRatesProvider(VAL_DATE, mockDf); prov.setDayCount(DAY_COUNT); return prov; }
public void test_presentValueSensitivity_df() { PointSensitivities point = PRICER.presentValueSensitivity(PAYMENT, DISCOUNT_FACTORS).build(); double relativeYearFraction = ACT_365F.relativeYearFraction(VAL_DATE_2014_01_22, PAYMENT_DATE); double expected = -DF * relativeYearFraction * NOTIONAL_USD; ZeroRateSensitivity actual = (ZeroRateSensitivity) point.getSensitivities().get(0); assertEquals(actual.getCurrency(), USD); assertEquals(actual.getCurveCurrency(), USD); assertEquals(actual.getYearFraction(), relativeYearFraction); assertEquals(actual.getSensitivity(), expected, NOTIONAL_USD * TOL); }
public void test_gamma_from_future_price() { double futurePrice = 1.1d; double computed = OPTION_PRICER.gammaStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOLS, futurePrice); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VAL_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.gamma(futurePrice, strike, expiryTime, vol); assertEquals(computed, expected, TOL); }
public void test_delta() { double computed = OPTION_PRICER.deltaStickyStrike(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOLS); double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlyingFuture(), RATE_PROVIDER); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VAL_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.delta(futurePrice, strike, expiryTime, vol, true); assertEquals(computed, expected, TOL); }
public void test_zeroRatePointSensitivityWithSpread_continous() { ZeroRatePeriodicDiscountFactors test = ZeroRatePeriodicDiscountFactors.of(GBP, DATE_VAL, CURVE); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double df = test.discountFactorWithSpread(DATE_AFTER, SPREAD, CONTINUOUS, 0); ZeroRateSensitivity expected = ZeroRateSensitivity.of(GBP, relativeYearFraction, -df * relativeYearFraction); ZeroRateSensitivity computed = test.zeroRatePointSensitivityWithSpread(DATE_AFTER, SPREAD, CONTINUOUS, 0); assertTrue(computed.compareKey(expected) == 0); assertEquals(computed.getSensitivity(), expected.getSensitivity(), TOLERANCE_DELTA); }
public void test_zeroRatePointSensitivityWithSpread_sensitivityCurrency_continous() { ZeroRatePeriodicDiscountFactors test = ZeroRatePeriodicDiscountFactors.of(GBP, DATE_VAL, CURVE); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double df = test.discountFactorWithSpread(DATE_AFTER, SPREAD, CONTINUOUS, 0); ZeroRateSensitivity expected = ZeroRateSensitivity.of(GBP, relativeYearFraction, USD, -df * relativeYearFraction); ZeroRateSensitivity computed = test.zeroRatePointSensitivityWithSpread(DATE_AFTER, USD, SPREAD, CONTINUOUS, 0); assertTrue(computed.compareKey(expected) == 0); assertEquals(computed.getSensitivity(), expected.getSensitivity(), TOLERANCE_DELTA); }
public void test_ofYield() { BillTrade test = sut_yield(); assertEquals(test.getProduct(), PRODUCT); assertEquals(test.getInfo(), TRADE_INFO); assertEquals(test.getQuantity(), QUANTITY); double price = 1.0d - YIELD * PRODUCT.getDayCount().relativeYearFraction(SETTLEMENT_DATE, PRODUCT.getNotional().getDate().getUnadjusted()); assertEquals(test.getPrice(), price, TOLERANCE_PRICE); assertEquals(test.withInfo(TRADE_INFO).getInfo(), TRADE_INFO); assertEquals(test.withQuantity(129).getQuantity(), 129d, 0d); assertEquals(test.withPrice(129).getPrice(), 129d, 0d); }
public void yield_from_price_intatmat() { ResolvedBill bill = BillTest.US_BILL .toBuilder().yieldConvention(BillYieldConvention.INTEREST_AT_MATURITY).build().resolve(REF_DATA); double price = 0.99; LocalDate settlementDate = LocalDate.of(2018, 8, 17); double af = bill.getDayCount().relativeYearFraction(settlementDate, bill.getNotional().getDate()); double yieldExpected = (1.0d / price - 1.0d) / af; double yieldComputed = bill.yieldFromPrice(price, settlementDate); assertEquals(yieldExpected, yieldComputed, TOLERANCE_PRICE); }
public void test_currencyParameterSensitivity() { SimpleDiscountFactors test = SimpleDiscountFactors.of(GBP, DATE_VAL, CURVE); ZeroRateSensitivity sens = test.zeroRatePointSensitivity(DATE_AFTER); double relativeYearFraction = ACT_365F.relativeYearFraction(DATE_VAL, DATE_AFTER); double discountFactor = CURVE.yValue(relativeYearFraction); CurrencyParameterSensitivities expected = CurrencyParameterSensitivities.of( CURVE.yValueParameterSensitivity(relativeYearFraction) .multipliedBy(-1d / discountFactor / relativeYearFraction) .multipliedBy(sens.getCurrency(), sens.getSensitivity())); assertEquals(test.parameterSensitivity(sens), expected); }