/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(ResolvedOvernightFutureTrade beanToCopy) { this.info = beanToCopy.getInfo(); this.product = beanToCopy.getProduct(); this.quantity = beanToCopy.getQuantity(); this.tradedPrice = beanToCopy.tradedPrice; }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 3237038: // info return ((ResolvedOvernightFutureTrade) bean).getInfo(); case -309474065: // product return ((ResolvedOvernightFutureTrade) bean).getProduct(); case -1285004149: // quantity return ((ResolvedOvernightFutureTrade) bean).getQuantity(); case -1873824343: // tradedPrice return ((ResolvedOvernightFutureTrade) bean).tradedPrice; } return super.propertyGet(bean, propertyName, quiet); }
/** * Calculates the present value sensitivity of the Overnight rate future trade. * <p> * The present value sensitivity of the trade is the sensitivity of the present value to * the underlying curves. * * @param trade the trade * @param ratesProvider the rates provider * @return the present value curve sensitivity of the trade */ public PointSensitivities presentValueSensitivity(ResolvedOvernightFutureTrade trade, RatesProvider ratesProvider) { ResolvedOvernightFuture product = trade.getProduct(); PointSensitivities priceSensi = productPricer.priceSensitivity(product, ratesProvider); PointSensitivities marginIndexSensi = productPricer.marginIndexSensitivity(product, priceSensi); return marginIndexSensi.multipliedBy(trade.getQuantity()); }
/** * Calculates the present value of the Overnight rate future trade from the current price. * <p> * The present value of the product is the value on the valuation date. * <p> * The calculation is performed against a reference price. The reference price * must be the last settlement price used for margining, except on the trade date, * when it must be the trade price. * * @param trade the trade * @param currentPrice the current price, in decimal form * @param referencePrice the reference price to margin against, typically the last settlement price, in decimal form * @return the present value */ CurrencyAmount presentValue(ResolvedOvernightFutureTrade trade, double currentPrice, double referencePrice) { ResolvedOvernightFuture future = trade.getProduct(); double priceIndex = productPricer.marginIndex(future, currentPrice); double referenceIndex = productPricer.marginIndex(future, referencePrice); double pv = (priceIndex - referenceIndex) * trade.getQuantity(); return CurrencyAmount.of(future.getCurrency(), pv); }
public void test_builder() { ResolvedOvernightFutureTrade test = ResolvedOvernightFutureTrade.builder() .info(TRADE_INFO) .product(PRODUCT) .quantity(QUANTITY) .tradedPrice(TradedPrice.of(TRADE_DATE, PRICE)) .build(); assertEquals(test.getInfo(), TRADE_INFO); assertEquals(test.getProduct(), PRODUCT); assertEquals(test.getQuantity(), QUANTITY); assertEquals(test.getTradedPrice(), Optional.of(TradedPrice.of(TRADE_DATE, PRICE))); }
public void test_presentValue() { double currentPrice = 0.995; double referencePrice = 0.9925; double currentPriceIndex = PRICER_PRODUCT.marginIndex(RESOLVED_TRADE.getProduct(), currentPrice); double referencePriceIndex = PRICER_PRODUCT.marginIndex(RESOLVED_TRADE.getProduct(), referencePrice); double presentValueExpected = (currentPriceIndex - referencePriceIndex) * RESOLVED_TRADE.getQuantity(); CurrencyAmount presentValueComputed = PRICER_TRADE.presentValue(RESOLVED_TRADE, currentPrice, referencePrice); assertEquals(presentValueComputed.getAmount(), presentValueExpected, TOLERANCE_PV); }
public void test_resolve() { OvernightFutureTrade test = OvernightFutureTrade.builder() .info(TRADE_INFO) .product(PRODUCT) .quantity(QUANTITY) .price(PRICE) .build(); ResolvedOvernightFutureTrade resolved = test.resolve(REF_DATA); assertEquals(resolved.getInfo(), TRADE_INFO); assertEquals(resolved.getProduct(), PRODUCT.resolve(REF_DATA)); assertEquals(resolved.getQuantity(), QUANTITY); assertEquals(resolved.getTradedPrice(), Optional.of(TradedPrice.of(TRADE_DATE, PRICE))); }
public void test_presentValue_after_trade_date() { double lastClosingPrice = 1.005; double expected = (PRICER_PRODUCT.price(RESOLVED_TRADE.getProduct(), RATES_PROVIDER_AFTER) - lastClosingPrice) * FUTURE.getAccrualFactor() * FUTURE.getNotional() * RESOLVED_TRADE.getQuantity(); CurrencyAmount computed = PRICER_TRADE.presentValue(RESOLVED_TRADE, RATES_PROVIDER_AFTER, lastClosingPrice); assertEquals(computed.getAmount(), expected, NOTIONAL * TOL); assertEquals(computed.getCurrency(), FUTURE.getCurrency()); }
public void test_presentValue_on_trade_date() { double lastClosingPrice = 1.005; double expected = (PRICER_PRODUCT.price(RESOLVED_TRADE.getProduct(), RATES_PROVIDER_ON) - RESOLVED_TRADE.getTradedPrice().get().getPrice()) * FUTURE.getAccrualFactor() * FUTURE.getNotional() * RESOLVED_TRADE.getQuantity(); CurrencyAmount computed = PRICER_TRADE.presentValue(RESOLVED_TRADE, RATES_PROVIDER_ON, lastClosingPrice); assertEquals(computed.getAmount(), expected, TOLERANCE_PV); assertEquals(computed.getCurrency(), FUTURE.getCurrency()); }
public void test_presentValueSensitivity() { PointSensitivities computed = PRICER_TRADE.presentValueSensitivity(RESOLVED_TRADE, RATES_PROVIDER); PointSensitivities expected = PRICER_PRODUCT.priceSensitivity(RESOLVED_TRADE.getProduct(), RATES_PROVIDER) .multipliedBy(FUTURE.getNotional() * FUTURE.getAccrualFactor() * RESOLVED_TRADE.getQuantity()); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * TOL)); }