//------------------------------------------------------------------------- /// <summary> /// Calculates the current of the FX vanilla option trade. /// </summary> /// <param name="trade"> the option trade </param> /// <param name="valuationDate"> the valuation date </param> /// <returns> the current cash amount </returns> public virtual CurrencyAmount currentCash(ResolvedFxVanillaOptionTrade trade, LocalDate valuationDate) { Payment premium = trade.Premium; if (premium.Date.Equals(valuationDate)) { return(CurrencyAmount.of(premium.Currency, premium.Amount)); } return(CurrencyAmount.of(premium.Currency, 0d)); }
// present value for one scenario internal MultiCurrencyAmount presentValue(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { if (method == FxVanillaOptionMethod.VANNA_VOLGA) { return(vannaVolgaPricer.presentValue(trade, ratesProvider, checkVannaVolgaVolatilities(volatilities))); } else { return(blackPricer.presentValue(trade, ratesProvider, checkBlackVolatilities(volatilities))); } }
// current cash for one scenario internal CurrencyAmount currentCash(ResolvedFxVanillaOptionTrade trade, LocalDate valuationDate, FxVanillaOptionMethod method) { if (method == FxVanillaOptionMethod.VANNA_VOLGA) { return(vannaVolgaPricer.currentCash(trade, valuationDate)); } else { return(blackPricer.currentCash(trade, valuationDate)); } }
// point sensitivity private CurrencyParameterSensitivities pointSensitivity(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { PointSensitivities pointSens; if (method == FxVanillaOptionMethod.VANNA_VOLGA) { pointSens = vannaVolgaPricer.presentValueSensitivityRatesStickyStrike(trade, ratesProvider, checkVannaVolgaVolatilities(volatilities)); } else { pointSens = blackPricer.presentValueSensitivityRatesStickyStrike(trade, ratesProvider, checkBlackVolatilities(volatilities)); } return(ratesProvider.parameterSensitivity(pointSens)); }
public virtual void test_price_presentValue_afterExpiry() { for (int i = 0; i < NB_STRIKES; ++i) { ResolvedFxVanillaOption call = CALLS[i]; ResolvedFxVanillaOptionTrade callTrade = ResolvedFxVanillaOptionTrade.builder().product(call).premium(Payment.of(EUR, 0, VOLS_AFTER.ValuationDate)).build(); double computedPriceCall = PRICER.price(call, RATES_PROVIDER_AFTER, VOLS_AFTER); CurrencyAmount computedCall = PRICER.presentValue(call, RATES_PROVIDER_AFTER, VOLS_AFTER); assertEquals(computedPriceCall, 0d, TOL); assertEquals(computedCall.Amount, 0d, TOL); ResolvedFxVanillaOption put = PUTS[i]; ResolvedFxVanillaOptionTrade putTrade = ResolvedFxVanillaOptionTrade.builder().product(put).premium(Payment.of(EUR, 0, VOLS_AFTER.ValuationDate)).build(); double computedPricePut = PRICER.price(put, RATES_PROVIDER_AFTER, VOLS_AFTER); CurrencyAmount computedPut = PRICER.presentValue(put, RATES_PROVIDER_AFTER, VOLS_AFTER); assertEquals(computedPricePut, 0d, TOL); assertEquals(computedPut.Amount, 0d, TOL); // test against trade pricer assertEquals(computedCall, TRADE_PRICER.presentValue(callTrade, RATES_PROVIDER_AFTER, VOLS_AFTER).getAmount(USD)); assertEquals(computedPut, TRADE_PRICER.presentValue(putTrade, RATES_PROVIDER_AFTER, VOLS_AFTER).getAmount(USD)); } }
//------------------------------------------------------------------------- // calculates current cash for all scenarios internal CurrencyScenarioArray currentCash(ResolvedFxVanillaOptionTrade trade, RatesScenarioMarketData ratesMarketData, FxOptionScenarioMarketData optionMarketData, FxVanillaOptionMethod method) { return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => currentCash(trade, ratesMarketData.scenario(i).ValuationDate, method))); }
// market quote bucketed PV01 for one scenario internal CurrencyParameterSensitivities pv01RatesMarketQuoteBucketed(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { CurrencyParameterSensitivities paramSens = pointSensitivity(trade, ratesProvider, volatilities, method); return(MARKET_QUOTE_SENS.sensitivity(paramSens, ratesProvider).multipliedBy(ONE_BASIS_POINT)); }
//------------------------------------------------------------------------- // calculates market quote bucketed PV01 for all scenarios internal ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedFxVanillaOptionTrade trade, RatesScenarioMarketData ratesMarketData, FxOptionScenarioMarketData optionMarketData, FxVanillaOptionMethod method) { CurrencyPair currencyPair = trade.Product.CurrencyPair; return(ScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesMarketQuoteBucketed(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(currencyPair), method))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="fxLookup"> the lookup used to query the option market data </param> /// <param name="marketData"> the market data </param> /// <param name="method"> the pricing method </param> /// <returns> the present value, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray presentValue(ResolvedFxVanillaOptionTrade trade, RatesMarketDataLookup ratesLookup, FxOptionMarketDataLookup fxLookup, ScenarioMarketData marketData, FxVanillaOptionMethod method) { return(calc.presentValue(trade, ratesLookup.marketDataView(marketData), fxLookup.marketDataView(marketData), method)); }
/// <summary> /// Calculates current cash for a single set of market data. /// <para> /// The sum of all cash flows paid on the valuation date. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <param name="volatilities"> the option volatilities </param> /// <param name="method"> the pricing method </param> /// <returns> the current cash </returns> public virtual CurrencyAmount currentCash(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { return(calc.currentCash(trade, ratesProvider.ValuationDate, method)); }
/// <summary> /// Calculates present value sensitivity for a single set of market data. /// <para> /// This is the sensitivity of present value to a one basis point shift in /// the market quotes used to calibrate the curves. /// The result is provided for each affected curve and currency, bucketed by curve node. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <param name="volatilities"> the option volatilities </param> /// <param name="method"> the pricing method </param> /// <returns> the present value sensitivity </returns> public virtual CurrencyParameterSensitivities pv01RatesMarketQuoteBucketed(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { return(calc.pv01RatesMarketQuoteBucketed(trade, ratesProvider, volatilities, method)); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of present value to a one basis point shift in /// the market quotes used to calibrate the curves. /// The result is provided for each affected curve and currency, bucketed by curve node. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <param name="fxLookup"> the lookup used to query the option market data </param> /// <param name="method"> the pricing method </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedFxVanillaOptionTrade trade, RatesMarketDataLookup ratesLookup, FxOptionMarketDataLookup fxLookup, ScenarioMarketData marketData, FxVanillaOptionMethod method) { return(calc.pv01RatesMarketQuoteBucketed(trade, ratesLookup.marketDataView(marketData), fxLookup.marketDataView(marketData), method)); }
/// <summary> /// Calculates present value sensitivity for a single set of market data. /// <para> /// This is the sensitivity of present value to a one basis point shift in /// the market quotes used to calibrate the curves. /// The result is the sum of the sensitivities of all affected curves. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <param name="volatilities"> the option volatilities </param> /// <param name="method"> the pricing method </param> /// <returns> the present value sensitivity </returns> public virtual MultiCurrencyAmount pv01RatesMarketQuoteSum(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { return(calc.pv01RatesMarketQuoteSum(trade, ratesProvider, volatilities, method)); }
//------------------------------------------------------------------------- // calculates calibrated sum PV01 for all scenarios internal MultiCurrencyScenarioArray pv01RatesCalibratedSum(ResolvedFxVanillaOptionTrade trade, RatesScenarioMarketData ratesMarketData, FxOptionScenarioMarketData optionMarketData, FxVanillaOptionMethod method) { CurrencyPair currencyPair = trade.Product.CurrencyPair; return(MultiCurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => pv01RatesCalibratedSum(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(currencyPair), method))); }
/// <summary> /// Calculates present value for a single set of market data. /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <param name="volatilities"> the option volatilities </param> /// <param name="method"> the pricing method </param> /// <returns> the present value </returns> public virtual MultiCurrencyAmount presentValue(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { return(calc.presentValue(trade, ratesProvider, volatilities, method)); }
// calibrated sum PV01 for one scenario internal MultiCurrencyAmount pv01RatesCalibratedSum(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, FxOptionVolatilities volatilities, FxVanillaOptionMethod method) { CurrencyParameterSensitivities paramSens = pointSensitivity(trade, ratesProvider, volatilities, method); return(paramSens.total().multipliedBy(ONE_BASIS_POINT)); }
//------------------------------------------------------------------------- /// <summary> /// Computes the present value sensitivity to the black volatility used in the pricing. /// <para> /// The result is a single sensitivity to the volatility used. /// /// </para> /// </summary> /// <param name="trade"> the option trade </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="volatilities"> the Black volatility provider </param> /// <returns> the present value sensitivity </returns> public virtual PointSensitivities presentValueSensitivityModelParamsVolatility(ResolvedFxVanillaOptionTrade trade, RatesProvider ratesProvider, BlackFxOptionSmileVolatilities volatilities) { ResolvedFxVanillaOption product = trade.Product; return(productPricer.presentValueSensitivityModelParamsVolatility(product, ratesProvider, volatilities).build()); }