/** * Computes the future price curve sensitivity. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @return The curve sensitivity. */ public MulticurveSensitivity priceCurveSensitivity( final BondFuture future, final IssuerProviderInterface issuerMulticurves) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final double[] priceFromBond = new double[future.getDeliveryBasket().length]; int indexCTD = 0; double priceMin = 2.0; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { priceFromBond[loopbasket] = (BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves)) / future.getConversionFactor()[loopbasket]; if (priceFromBond[loopbasket] < priceMin) { priceMin = priceFromBond[loopbasket]; indexCTD = loopbasket; } } MulticurveSensitivity result = BOND_METHOD.dirtyPriceCurveSensitivity( future.getDeliveryBasket()[indexCTD], issuerMulticurves); return result.multipliedBy(1.0 / future.getConversionFactor()[indexCTD]); }
/** * Computes the net basis of associated to the cheapest to deliver bonds in the underlying basket * from the curves and the future price. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param futurePrice The future price. * @return The net basis. */ public double netBasisCheapest( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double futurePrice) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final int nbBasket = future.getDeliveryBasket().length; final double[] netBasis = new double[nbBasket]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { netBasis[loopbasket] = BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves) - futurePrice * future.getConversionFactor()[loopbasket]; } return MIN_FUNCTION.evaluate(netBasis); }
/** * Computes the future price from the curves used to price the underlying bonds and the net basis. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param netBasis The net basis associated to the future. * @return The future price. */ public double priceFromNetBasis( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double netBasis) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final double[] priceFromBond = new double[future.getDeliveryBasket().length]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { priceFromBond[loopbasket] = (BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves) - netBasis) / future.getConversionFactor()[loopbasket]; } final double priceFuture = MIN_FUNCTION.evaluate(priceFromBond); return priceFuture; }
/** * Computes the gross basis of the bonds in the underlying basket from the curves. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param futurePrice The future price. * @return The gross basis for each bond in the basket. */ public double[] grossBasisFromCurves( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double futurePrice) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final int nbBasket = future.getDeliveryBasket().length; final double[] grossBasis = new double[nbBasket]; final double[] cleanPrices = new double[nbBasket]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { cleanPrices[loopbasket] = BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves); grossBasis[loopbasket] = cleanPrices[loopbasket] - futurePrice * future.getConversionFactor()[loopbasket]; } return grossBasis; }
/** * Method to compute the price of bond future as the cheapest forward. * * @deprecated Use the {@link BondFuturesTransactionDiscountingMethod}. */ @Deprecated public final class BondFutureDiscountingMethod extends BondFutureMethod { /** Creates the method unique instance. */ private static final BondFutureDiscountingMethod INSTANCE = new BondFutureDiscountingMethod(); /** * Return the method unique instance. * * @return The instance. */ public static BondFutureDiscountingMethod getInstance() { return INSTANCE; } /** Constructor. */ private BondFutureDiscountingMethod() {} /** The method to compute bond security figures. */ private static final BondSecurityDiscountingMethod BOND_METHOD = BondSecurityDiscountingMethod.getInstance(); /** Method used to compute the minimum of an array. */ private static final Min MIN_FUNCTION = new Min(); /** * Computes the future price from the curves used to price the underlying bonds. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @return The future price. */ public double price(final BondFuture future, final IssuerProviderInterface issuerMulticurves) { return priceFromNetBasis(future, issuerMulticurves, 0.0); } /** * Computes the future price from the curves used to price the underlying bonds and the net basis. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param netBasis The net basis associated to the future. * @return The future price. */ public double priceFromNetBasis( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double netBasis) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final double[] priceFromBond = new double[future.getDeliveryBasket().length]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { priceFromBond[loopbasket] = (BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves) - netBasis) / future.getConversionFactor()[loopbasket]; } final double priceFuture = MIN_FUNCTION.evaluate(priceFromBond); return priceFuture; } /** * Computes the present value of future from the curves using the cheapest-to-deliver and * computing the value as a forward. * * @param future The future. * @param issuerMulticurves The issuer and multi-curves provider. * @return The present value. */ public MultipleCurrencyAmount presentValue( final BondFuture future, final IssuerProviderInterface issuerMulticurves) { return presentValueFromPrice(future, price(future, issuerMulticurves)); } /** * Computes the present value of future from the curves using the cheapest-to-deliver and * computing the value as a forward. * * @param future The future. * @param issuerMulticurves The issuer and multi-curves provider. * @param netBasis The net basis associated to the future. * @return The present value. */ public MultipleCurrencyAmount presentValueFromNetBasis( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double netBasis) { return presentValueFromPrice(future, priceFromNetBasis(future, issuerMulticurves, netBasis)); } /** * Computes the future price curve sensitivity. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @return The curve sensitivity. */ public MulticurveSensitivity priceCurveSensitivity( final BondFuture future, final IssuerProviderInterface issuerMulticurves) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final double[] priceFromBond = new double[future.getDeliveryBasket().length]; int indexCTD = 0; double priceMin = 2.0; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { priceFromBond[loopbasket] = (BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves)) / future.getConversionFactor()[loopbasket]; if (priceFromBond[loopbasket] < priceMin) { priceMin = priceFromBond[loopbasket]; indexCTD = loopbasket; } } MulticurveSensitivity result = BOND_METHOD.dirtyPriceCurveSensitivity( future.getDeliveryBasket()[indexCTD], issuerMulticurves); return result.multipliedBy(1.0 / future.getConversionFactor()[indexCTD]); } /** * Compute the present value sensitivity to rates of a bond future by discounting. * * @param future The future. * @param issuerMulticurves The issuer and multi-curves provider. * @return The present value rate sensitivity. */ public MultipleCurrencyMulticurveSensitivity presentValueCurveSensitivity( final BondFuture future, final IssuerProviderInterface issuerMulticurves) { Currency ccy = future.getCurrency(); final MulticurveSensitivity priceSensitivity = priceCurveSensitivity(future, issuerMulticurves); final MultipleCurrencyMulticurveSensitivity transactionSensitivity = MultipleCurrencyMulticurveSensitivity.of( ccy, priceSensitivity.multipliedBy(future.getNotional())); return transactionSensitivity; } /** * Computes the gross basis of the bonds in the underlying basket from their clean prices. * * @param future The future security. * @param cleanPrices The clean prices (at standard bond market spot date) of the bond in the * basket. * @param futurePrice The future price. * @return The gross basis for each bond in the basket. */ public double[] grossBasisFromPrices( final BondFuture future, final double[] cleanPrices, final double futurePrice) { ArgumentChecker.notNull(future, "Future"); final int nbBasket = future.getDeliveryBasket().length; ArgumentChecker.isTrue(cleanPrices.length == nbBasket, "Number of clean prices"); final double[] grossBasis = new double[nbBasket]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { grossBasis[loopbasket] = cleanPrices[loopbasket] - futurePrice * future.getConversionFactor()[loopbasket]; } return grossBasis; } /** * Computes the gross basis of the bonds in the underlying basket from the curves. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param futurePrice The future price. * @return The gross basis for each bond in the basket. */ public double[] grossBasisFromCurves( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double futurePrice) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final int nbBasket = future.getDeliveryBasket().length; final double[] grossBasis = new double[nbBasket]; final double[] cleanPrices = new double[nbBasket]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { cleanPrices[loopbasket] = BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves); grossBasis[loopbasket] = cleanPrices[loopbasket] - futurePrice * future.getConversionFactor()[loopbasket]; } return grossBasis; } /** * Computes the net basis of all the bonds in the underlying basket from the curves and the future * price. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param futurePrice The future price. * @return The net basis for each bond in the basket. */ public double[] netBasisAllBonds( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double futurePrice) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final int nbBasket = future.getDeliveryBasket().length; final double[] netBasis = new double[nbBasket]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { netBasis[loopbasket] = BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves) - futurePrice * future.getConversionFactor()[loopbasket]; } return netBasis; } /** * Computes the net basis of associated to the cheapest to deliver bonds in the underlying basket * from the curves and the future price. * * @param future The future security. * @param issuerMulticurves The issuer and multi-curves provider. * @param futurePrice The future price. * @return The net basis. */ public double netBasisCheapest( final BondFuture future, final IssuerProviderInterface issuerMulticurves, final double futurePrice) { ArgumentChecker.notNull(future, "Future"); ArgumentChecker.notNull(issuerMulticurves, "Issuer and multi-curves provider"); final int nbBasket = future.getDeliveryBasket().length; final double[] netBasis = new double[nbBasket]; for (int loopbasket = 0; loopbasket < future.getDeliveryBasket().length; loopbasket++) { netBasis[loopbasket] = BOND_METHOD.cleanPriceFromCurves( future.getDeliveryBasket()[loopbasket], issuerMulticurves) - futurePrice * future.getConversionFactor()[loopbasket]; } return MIN_FUNCTION.evaluate(netBasis); } }