/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(ResolvedCdsIndexTrade beanToCopy) { this.info = beanToCopy.getInfo(); this.product = beanToCopy.getProduct(); this.upfrontFee = beanToCopy.upfrontFee; }
@Override public ResolvedCdsIndexTrade build() { return new ResolvedCdsIndexTrade( info, product, upfrontFee); }
public void test_builder_min() { ResolvedCdsIndexTrade test = ResolvedCdsIndexTrade.builder() .product(PRODUCT) .info(TRADE_INFO) .build(); assertEquals(test.getProduct(), PRODUCT); assertEquals(test.getInfo(), TRADE_INFO); assertFalse(test.getUpfrontFee().isPresent()); ResolvedCdsTrade singleName = test.toSingleNameCds(); assertEquals(singleName.getProduct(), PRODUCT.toSingleNameCds()); assertEquals(singleName.getInfo(), TRADE_INFO); assertFalse(singleName.getUpfrontFee().isPresent()); }
public void test_full_resolve() { ResolvedCdsIndexTrade test = sut() .resolve(REF_DATA); assertEquals(test.getProduct(), PRODUCT.resolve(REF_DATA)); assertEquals(test.getInfo(), TRADE_INFO); assertEquals(test.getUpfrontFee().get(), UPFRONT.resolve(REF_DATA)); }
/** * Calculates the expected loss of the underlying product. * <p> * The expected loss is the (undiscounted) expected default settlement value paid by the protection seller. * The resulting value is always positive. * * @param trade the trade * @param ratesProvider the rates provider * @return the recovery01 */ public CurrencyAmount expectedLoss( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider) { return productPricer.expectedLoss(trade.getProduct(), ratesProvider); }
/** * Calculates the present value of the trade. * <p> * The present value of the product is based on the valuation date. * <p> * This method can calculate the clean or dirty present value, see {@link PriceType}. * If calculating the clean value, the accrued interest is calculated based on the step-in date. * * @param trade the trade * @param ratesProvider the rates provider * @param priceType the price type * @param refData the reference data * @return the price */ public CurrencyAmount presentValue( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, PriceType priceType, ReferenceData refData) { CurrencyAmount pvProduct = productPricer.presentValue( trade.getProduct(), ratesProvider, ratesProvider.getValuationDate(), priceType, refData); if (!trade.getUpfrontFee().isPresent()) { return pvProduct; } Payment upfront = trade.getUpfrontFee().get(); CurrencyAmount pvUpfront = upfrontPricer.presentValue(upfront, ratesProvider.discountFactors(upfront.getCurrency()).toDiscountFactors()); return pvProduct.plus(pvUpfront); }
/** * Computes bucketed CS01 for CDS index using a single credit curve. * <p> * This is coherent to the pricer {@link IsdaHomogenousCdsIndexTradePricer}. * The relevant credit curve must be stored in {@code RatesProvider}. * * @param trade the trade * @param bucketCdsIndex the CDS index bucket * @param ratesProvider the rates provider * @param refData the reference data * @return the bucketed CS01 */ public CurrencyParameterSensitivity bucketedCs01( ResolvedCdsIndexTrade trade, List<ResolvedCdsIndexTrade> bucketCdsIndex, CreditRatesProvider ratesProvider, ReferenceData refData) { ResolvedCdsTrade cdsTrade = trade.toSingleNameCds(); List<ResolvedCdsTrade> bucketCds = bucketCdsIndex.stream() .map(ResolvedCdsIndexTrade::toSingleNameCds) .collect(Collectors.toList()); List<ResolvedTradeParameterMetadata> metadata = bucketCdsIndex.stream() .map(t -> ResolvedTradeParameterMetadata.of(t, t.getProduct().getProtectionEndDate().toString())) .collect(Guavate.toImmutableList()); CurrencyParameterSensitivity bucketedCs01 = bucketedCs01(cdsTrade, bucketCds, metadata, ratesProvider, refData); double indexFactor = getIndexFactor(cdsTrade.getProduct(), ratesProvider); return bucketedCs01.multipliedBy(indexFactor); }
@Override public ResolvedCdsIndexTrade resolve(ReferenceData refData) { return ResolvedCdsIndexTrade.builder() .info(info) .product(product.resolve(refData)) .upfrontFee(upfrontFee != null ? upfrontFee.resolve(refData) : null) .build(); }
/** * Computes parallel CS01 for CDS index using a single credit curve. * <p> * This is coherent to the pricer {@link IsdaHomogenousCdsIndexTradePricer}. * The relevant credit curve must be stored in {@code RatesProvider}. * * @param trade the trade * @param bucketCdsIndex the CDS index bucket * @param ratesProvider the rates provider * @param refData the reference data * @return the parallel CS01 */ public CurrencyAmount parallelCs01( ResolvedCdsIndexTrade trade, List<ResolvedCdsIndexTrade> bucketCdsIndex, CreditRatesProvider ratesProvider, ReferenceData refData) { ResolvedCdsTrade cdsTrade = trade.toSingleNameCds(); List<ResolvedCdsTrade> bucketCds = bucketCdsIndex.stream() .map(ResolvedCdsIndexTrade::toSingleNameCds) .collect(Collectors.toList()); CurrencyAmount cs01Cds = parallelCs01(cdsTrade, bucketCds, ratesProvider, refData); double indexFactor = getIndexFactor(cdsTrade.getProduct(), ratesProvider); return cs01Cds.multipliedBy(indexFactor); }
public void test_builder_full() { ResolvedCdsIndexTrade test = ResolvedCdsIndexTrade.builder() .product(PRODUCT) .info(TRADE_INFO) .upfrontFee(UPFRONT) .build(); assertEquals(test.getProduct(), PRODUCT); assertEquals(test.getInfo(), TRADE_INFO); assertEquals(test.getUpfrontFee().get(), UPFRONT); ResolvedCdsTrade singleName = test.toSingleNameCds(); assertEquals(singleName.getProduct(), PRODUCT.toSingleNameCds()); assertEquals(singleName.getInfo(), TRADE_INFO); assertEquals(singleName.getUpfrontFee().get(), UPFRONT); }
public void test_min_resolve() { ResolvedCdsIndexTrade test = CdsIndexTrade.builder() .product(PRODUCT) .info(TRADE_INFO) .build() .resolve(REF_DATA); assertEquals(test.getProduct(), PRODUCT.resolve(REF_DATA)); assertEquals(test.getInfo(), TRADE_INFO); assertFalse(test.getUpfrontFee().isPresent()); }
/** * Computes bucketed CS01 for CDS index using a single credit curve. * <p> * This is coherent to the pricer {@link IsdaHomogenousCdsIndexTradePricer}. * The relevant credit curve must be stored in {@code RatesProvider}. * <p> * The CDS index trades used in the curve calibration are reused as bucket CDS index by this method. * Thus the credit curve must store {@link ResolvedTradeParameterMetadata}. * * @param trade the trade * @param ratesProvider the rates provider * @param refData the reference data * @return the bucketed CS01 */ public CurrencyParameterSensitivity bucketedCs01( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { List<ResolvedCdsIndexTrade> bucketCdsIndex = getBucketCdsIndex(trade.getProduct(), ratesProvider); return bucketedCs01(trade, bucketCdsIndex, ratesProvider, refData); }
/** * Calculates the present value sensitivity of the trade. * <p> * The present value sensitivity of the trade is the sensitivity of present value to the underlying curves. * * @param trade the trade * @param ratesProvider the rates provider * @param refData the reference data * @return the present value sensitivity */ public PointSensitivities presentValueSensitivity( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { PointSensitivityBuilder pvSensiProduct = productPricer.presentValueSensitivity( trade.getProduct(), ratesProvider, ratesProvider.getValuationDate(), refData); if (!trade.getUpfrontFee().isPresent()) { return pvSensiProduct.build(); } Payment upfront = trade.getUpfrontFee().get(); PointSensitivityBuilder pvUpfront = upfrontPricer.presentValueSensitivity( upfront, ratesProvider.discountFactors(upfront.getCurrency()).toDiscountFactors()); return pvSensiProduct.combinedWith(pvUpfront).build(); }
public void test_serialization() { ResolvedCdsIndexTrade test = ResolvedCdsIndexTrade.builder() .product(PRODUCT) .upfrontFee(UPFRONT) .info(TRADE_INFO) .build(); assertSerialization(test); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 3237038: // info return ((ResolvedCdsIndexTrade) bean).getInfo(); case -309474065: // product return ((ResolvedCdsIndexTrade) bean).getProduct(); case 963468344: // upfrontFee return ((ResolvedCdsIndexTrade) bean).upfrontFee; } return super.propertyGet(bean, propertyName, quiet); }
/** * Computes parallel CS01 for CDS index using a single credit curve. * <p> * This is coherent to the pricer {@link IsdaHomogenousCdsIndexTradePricer}. * The relevant credit curve must be stored in {@code RatesProvider}. * <p> * The CDS index trades used in the curve calibration are reused as bucket CDS index by this method. * Thus the credit curve must store {@link ResolvedTradeParameterMetadata}. * * @param trade the trade * @param ratesProvider the rates provider * @param refData the reference data * @return the parallel CS01 */ public CurrencyAmount parallelCs01( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { List<ResolvedCdsIndexTrade> bucketCdsIndex = getBucketCdsIndex(trade.getProduct(), ratesProvider); return parallelCs01(trade, bucketCdsIndex, ratesProvider, refData); }
public void coverage() { ResolvedCdsIndexTrade test1 = ResolvedCdsIndexTrade.builder() .product(PRODUCT) .upfrontFee(UPFRONT) .info(TRADE_INFO) .build(); coverImmutableBean(test1); ResolvedCdsIndex product = CdsIndex.of(BUY, INDEX_ID, LEGAL_ENTITIES, USD, 1.e9, START_DATE, END_DATE, P6M, SAT_SUN, 0.067).resolve(REF_DATA); ResolvedCdsIndexTrade test2 = ResolvedCdsIndexTrade.builder() .product(product) .info(TradeInfo.empty()) .build(); coverBeanEquals(test1, test2); }
private LocalDate calculateSettlementDate( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { return trade.getInfo().getSettlementDate() .orElse(trade.getProduct().calculateSettlementDateFromValuation(ratesProvider.getValuationDate(), refData)); }
/** * Calculates the price of the underlying product, which is the present value per unit notional. * <p> * This method can calculate the clean or dirty price, see {@link PriceType}. * If calculating the clean price, the accrued interest is calculated based on the step-in date. * <p> * This is coherent to {@link #presentValueOnSettle(ResolvedCdsIndexTrade, CreditRatesProvider, PriceType, ReferenceData)}. * * @param trade the trade * @param ratesProvider the rates provider * @param priceType the price type * @param refData the reference data * @return the price */ public double price( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, PriceType priceType, ReferenceData refData) { LocalDate settlementDate = calculateSettlementDate(trade, ratesProvider, refData); return productPricer.price(trade.getProduct(), ratesProvider, settlementDate, priceType, refData); }
/** * Calculates the par spread of the underlying product. * <p> * The par spread is a coupon rate such that the clean price is 0. * The result is represented in decimal form. * <p> * This is coherent to {@link #price(ResolvedCdsIndexTrade, CreditRatesProvider, PriceType, ReferenceData)}. * * @param trade the trade * @param ratesProvider the rates provider * @param refData the reference data * @return the par spread */ public double parSpread( ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { LocalDate settlementDate = calculateSettlementDate(trade, ratesProvider, refData); return productPricer.parSpread(trade.getProduct(), ratesProvider, settlementDate, refData); }