/// <summary>
/// Calculates the present value of the FX barrier option product.
/// <para>
/// The present value of the product is the value on the valuation date.
/// It is expressed in the counter currency.
/// </para>
/// <para>
/// This assumes the tree is already calibrated and the tree data is stored as {@code RecombiningTrinomialTreeData}.
/// The tree data should be consistent with the pricer and other inputs, see <seealso cref="#validateData"/>.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <param name="treeData"> the trinomial tree data </param>
/// <returns> the present value of the product </returns>
public virtual CurrencyAmount presentValue(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities, RecombiningTrinomialTreeData treeData)
{
double price = this.price(option, ratesProvider, volatilities, treeData);
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
return(CurrencyAmount.of(underlyingOption.CounterCurrency, signedNotional(underlyingOption) * price));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value theta of the FX barrier option product.
/// <para>
/// The present value theta is the negative of the first derivative of <seealso cref="#presentValue"/> with time parameter.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value theta of the product </returns>
public virtual CurrencyAmount presentValueTheta(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
double theta = this.theta(option, ratesProvider, volatilities);
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
return(CurrencyAmount.of(underlyingOption.CounterCurrency, signedNotional(underlyingOption) * theta));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price of the foreign exchange vanilla option product.
/// <para>
/// The price of the product is the value on the valuation date for one unit of the base currency
/// and is expressed in the counter currency. The price does not take into account the long/short flag.
/// See <seealso cref="#presentValue"/> for scaling and currency.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the price of the product </returns>
public virtual double price(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionSmileVolatilities volatilities)
{
validate(ratesProvider, volatilities);
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry <= 0d)
{
return(0d);
}
ResolvedFxSingle underlyingFx = option.Underlying;
Currency ccyCounter = option.CounterCurrency;
double df = ratesProvider.discountFactor(ccyCounter, underlyingFx.PaymentDate);
FxRate forward = fxPricer.forwardFxRate(underlyingFx, ratesProvider);
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
double forwardRate = forward.fxRate(currencyPair);
double strikeRate = option.Strike;
bool isCall = option.PutCall.Call;
SmileDeltaParameters smileAtTime = volatilities.Smile.smileForExpiry(timeToExpiry);
double[] strikes = smileAtTime.strike(forwardRate).toArray();
double[] vols = smileAtTime.Volatility.toArray();
double volAtm = vols[1];
double[] x = vannaVolgaWeights(forwardRate, strikeRate, timeToExpiry, volAtm, strikes);
double priceFwd = BlackFormulaRepository.price(forwardRate, strikeRate, timeToExpiry, volAtm, isCall);
for (int i = 0; i < 3; i += 2)
{
double priceFwdAtm = BlackFormulaRepository.price(forwardRate, strikes[i], timeToExpiry, volAtm, isCall);
double priceFwdSmile = BlackFormulaRepository.price(forwardRate, strikes[i], timeToExpiry, vols[i], isCall);
priceFwd += x[i] * (priceFwdSmile - priceFwdAtm);
}
return(df * priceFwd);
}
/// <summary>
/// Calculates the present value sensitivity of the FX barrier option product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of <seealso cref="#presentValue"/> to
/// the underlying curve parameters.
/// </para>
/// <para>
/// The sensitivity is computed by bump and re-price.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <param name="baseTreeData"> the trinomial tree data </param>
/// <returns> the present value of the product </returns>
public virtual CurrencyParameterSensitivities presentValueSensitivityRates(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities, RecombiningTrinomialTreeData baseTreeData)
{
ArgChecker.isTrue(baseTreeData.NumberOfSteps == calibrator.NumberOfSteps, "the number of steps mismatch between pricer and trinomial tree data");
double shift = 1.0e-5;
CurrencyAmount pvBase = presentValue(option, ratesProvider, volatilities, baseTreeData);
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
ImmutableRatesProvider immRatesProvider = ratesProvider.toImmutableRatesProvider();
ImmutableMap <Currency, Curve> baseCurves = immRatesProvider.DiscountCurves;
CurrencyParameterSensitivities result = CurrencyParameterSensitivities.empty();
foreach (KeyValuePair <Currency, Curve> entry in baseCurves.entrySet())
{
if (currencyPair.contains(entry.Key))
{
Curve curve = entry.Value;
int nParams = curve.ParameterCount;
DoubleArray sensitivity = DoubleArray.of(nParams, i =>
{
Curve dscBumped = curve.withParameter(i, curve.getParameter(i) + shift);
IDictionary <Currency, Curve> mapBumped = new Dictionary <Currency, Curve>(baseCurves);
mapBumped[entry.Key] = dscBumped;
ImmutableRatesProvider providerDscBumped = immRatesProvider.toBuilder().discountCurves(mapBumped).build();
double pvBumped = presentValue(option, providerDscBumped, volatilities).Amount;
return((pvBumped - pvBase.Amount) / shift);
});
result = result.combinedWith(curve.createParameterSensitivity(pvBase.Currency, sensitivity));
}
}
return(result);
}
//-------------------------------------------------------------------------
private void validateData(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities, RecombiningTrinomialTreeData data)
{
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
ArgChecker.isTrue(DoubleMath.fuzzyEquals(data.getTime(data.NumberOfSteps), volatilities.relativeTime(underlyingOption.Expiry), SMALL), "time to expiry mismatch between pricing option and trinomial tree data");
ArgChecker.isTrue(DoubleMath.fuzzyEquals(data.Spot, ratesProvider.fxRate(underlyingOption.Underlying.CurrencyPair), SMALL), "today's FX rate mismatch between rates provider and trinomial tree data");
}
//-------------------------------------------------------------------------
private ValueDerivatives priceDerivatives(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities, RecombiningTrinomialTreeData data)
{
validate(option, ratesProvider, volatilities);
validateData(option, ratesProvider, volatilities, data);
int nSteps = data.NumberOfSteps;
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
double timeToExpiry = data.getTime(nSteps);
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
Currency ccyBase = underlyingFx.CounterCurrencyPayment.Currency;
Currency ccyCounter = underlyingFx.CounterCurrencyPayment.Currency;
DiscountFactors baseDiscountFactors = ratesProvider.discountFactors(ccyBase);
DiscountFactors counterDiscountFactors = ratesProvider.discountFactors(ccyCounter);
double rebateAtExpiry = 0d; // used to price knock-in option
double rebateAtExpiryDerivative = 0d; // used to price knock-in option
double notional = Math.Abs(underlyingFx.BaseCurrencyPayment.Amount);
double[] rebateArray = new double[nSteps + 1];
SimpleConstantContinuousBarrier barrier = (SimpleConstantContinuousBarrier)option.Barrier;
if (option.Rebate.Present)
{
CurrencyAmount rebateCurrencyAmount = option.Rebate.get();
double rebatePerUnit = rebateCurrencyAmount.Amount / notional;
bool isCounter = rebateCurrencyAmount.Currency.Equals(ccyCounter);
double rebate = isCounter ? rebatePerUnit : rebatePerUnit * barrier.BarrierLevel;
if (barrier.KnockType.KnockIn)
{ // use in-out parity
double dfCounterAtExpiry = counterDiscountFactors.discountFactor(timeToExpiry);
double dfBaseAtExpiry = baseDiscountFactors.discountFactor(timeToExpiry);
for (int i = 0; i < nSteps + 1; ++i)
{
rebateArray[i] = isCounter ? rebate * dfCounterAtExpiry / counterDiscountFactors.discountFactor(data.getTime(i)) : rebate * dfBaseAtExpiry / baseDiscountFactors.discountFactor(data.getTime(i));
}
if (isCounter)
{
rebateAtExpiry = rebatePerUnit * dfCounterAtExpiry;
}
else
{
rebateAtExpiry = rebatePerUnit * data.Spot * dfBaseAtExpiry;
rebateAtExpiryDerivative = rebatePerUnit * dfBaseAtExpiry;
}
}
else
{
Arrays.fill(rebateArray, rebate);
}
}
ConstantContinuousSingleBarrierKnockoutFunction barrierFunction = ConstantContinuousSingleBarrierKnockoutFunction.of(underlyingOption.Strike, timeToExpiry, underlyingOption.PutCall, nSteps, barrier.BarrierType, barrier.BarrierLevel, DoubleArray.ofUnsafe(rebateArray));
ValueDerivatives barrierPrice = TREE.optionPriceAdjoint(barrierFunction, data);
if (barrier.KnockType.KnockIn)
{ // use in-out parity
EuropeanVanillaOptionFunction vanillaFunction = EuropeanVanillaOptionFunction.of(underlyingOption.Strike, timeToExpiry, underlyingOption.PutCall, nSteps);
ValueDerivatives vanillaPrice = TREE.optionPriceAdjoint(vanillaFunction, data);
return(ValueDerivatives.of(vanillaPrice.Value + rebateAtExpiry - barrierPrice.Value, DoubleArray.of(vanillaPrice.getDerivative(0) + rebateAtExpiryDerivative - barrierPrice.getDerivative(0))));
}
return(barrierPrice);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the price of the foreign exchange vanilla option product.
/// <para>
/// The price of the product is the value on the valuation date for one unit of the base currency
/// and is expressed in the counter currency. The price does not take into account the long/short flag.
/// See <seealso cref="#presentValue"/> for scaling and currency.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the price of the product </returns>
public virtual double price(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
ResolvedFxSingle underlying = option.Underlying;
double forwardPrice = undiscountedPrice(option, ratesProvider, volatilities);
double discountFactor = ratesProvider.discountFactor(option.CounterCurrency, underlying.PaymentDate);
return(discountFactor * forwardPrice);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the delta of the foreign exchange vanilla option product.
/// <para>
/// The delta is the first derivative of <seealso cref="#price"/> with respect to spot.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the delta of the product </returns>
public virtual double delta(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
ResolvedFxSingle underlying = option.Underlying;
double fwdDelta = undiscountedDelta(option, ratesProvider, volatilities);
double discountFactor = ratesProvider.discountFactor(option.CounterCurrency, underlying.PaymentDate);
double fwdRateSpotSensitivity = fxPricer.forwardFxRateSpotSensitivity(option.PutCall.Call ? underlying : underlying.inverse(), ratesProvider);
return(fwdDelta * discountFactor * fwdRateSpotSensitivity);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the currency exposure of the foreign exchange vanilla option product.
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
CurrencyPair strikePair = option.Underlying.CurrencyPair;
double price = this.price(option, ratesProvider, volatilities);
double delta = this.delta(option, ratesProvider, volatilities);
double spot = ratesProvider.fxRate(strikePair);
double signedNotional = this.signedNotional(option);
CurrencyAmount domestic = CurrencyAmount.of(strikePair.Counter, (price - delta * spot) * signedNotional);
CurrencyAmount foreign = CurrencyAmount.of(strikePair.Base, delta * signedNotional);
return(MultiCurrencyAmount.of(domestic, foreign));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the implied Black volatility of the foreign exchange vanilla option product.
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the implied volatility of the product </returns>
/// <exception cref="IllegalArgumentException"> if the option has expired </exception>
public virtual double impliedVolatility(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry <= 0d)
{
throw new System.ArgumentException("valuation is after option's expiry.");
}
FxRate forward = fxPricer.forwardFxRate(option.Underlying, ratesProvider);
CurrencyPair strikePair = option.Underlying.CurrencyPair;
return(volatilities.volatility(strikePair, option.Expiry, option.Strike, forward.fxRate(strikePair)));
}
/// <summary>
/// Calculates the currency exposure of the FX barrier option product.
/// <para>
/// This assumes the tree is already calibrated and the tree data is stored as {@code RecombiningTrinomialTreeData}.
/// The tree data should be consistent with the pricer and other inputs, see <seealso cref="#validateData"/>.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <param name="treeData"> the trinomial tree data </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities, RecombiningTrinomialTreeData treeData)
{
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
ValueDerivatives priceDerivatives = this.priceDerivatives(option, ratesProvider, volatilities, treeData);
double price = priceDerivatives.Value;
double delta = priceDerivatives.getDerivative(0);
CurrencyPair currencyPair = underlyingOption.Underlying.CurrencyPair;
double todayFx = ratesProvider.fxRate(currencyPair);
double signedNotional = this.signedNotional(underlyingOption);
CurrencyAmount domestic = CurrencyAmount.of(currencyPair.Counter, (price - delta * todayFx) * signedNotional);
CurrencyAmount foreign = CurrencyAmount.of(currencyPair.Base, delta * signedNotional);
return(MultiCurrencyAmount.of(domestic, foreign));
}
/// <summary>
/// Calculates the present value sensitivity of the foreign exchange vanilla option product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of <seealso cref="#presentValue"/> to
/// the underlying curves.
/// </para>
/// <para>
/// The volatility is fixed in this sensitivity computation.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value curve sensitivity of the product </returns>
public virtual PointSensitivities presentValueSensitivityRatesStickyStrike(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
if (volatilities.relativeTime(option.Expiry) < 0d)
{
return(PointSensitivities.empty());
}
ResolvedFxSingle underlying = option.Underlying;
double fwdDelta = undiscountedDelta(option, ratesProvider, volatilities);
double discountFactor = ratesProvider.discountFactor(option.CounterCurrency, underlying.PaymentDate);
double notional = signedNotional(option);
PointSensitivityBuilder fwdSensi = fxPricer.forwardFxRatePointSensitivity(option.PutCall.Call ? underlying : underlying.inverse(), ratesProvider).multipliedBy(notional * discountFactor * fwdDelta);
double fwdPrice = undiscountedPrice(option, ratesProvider, volatilities);
PointSensitivityBuilder dscSensi = ratesProvider.discountFactors(option.CounterCurrency).zeroRatePointSensitivity(underlying.PaymentDate).multipliedBy(notional * fwdPrice);
return(fwdSensi.combinedWith(dscSensi).build().convertedTo(option.CounterCurrency, ratesProvider));
}
//-------------------------------------------------------------------------
// The derivatives are [0] spot, [1] strike, [2] rate, [3] cost-of-carry, [4] volatility, [5] timeToExpiry, [6] spot twice
private ValueDerivatives priceDerivatives(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
validate(option, ratesProvider, volatilities);
SimpleConstantContinuousBarrier barrier = (SimpleConstantContinuousBarrier)option.Barrier;
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
double[] derivatives = new double[7];
if (volatilities.relativeTime(underlyingOption.Expiry) < 0d)
{
return(ValueDerivatives.of(0d, DoubleArray.ofUnsafe(derivatives)));
}
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
Currency ccyBase = currencyPair.Base;
Currency ccyCounter = currencyPair.Counter;
DiscountFactors baseDiscountFactors = ratesProvider.discountFactors(ccyBase);
DiscountFactors counterDiscountFactors = ratesProvider.discountFactors(ccyCounter);
double rateBase = baseDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double rateCounter = counterDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double costOfCarry = rateCounter - rateBase;
double dfBase = baseDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double dfCounter = counterDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double todayFx = ratesProvider.fxRate(currencyPair);
double strike = underlyingOption.Strike;
double forward = todayFx * dfBase / dfCounter;
double volatility = volatilities.volatility(currencyPair, underlyingOption.Expiry, strike, forward);
double timeToExpiry = volatilities.relativeTime(underlyingOption.Expiry);
ValueDerivatives valueDerivatives = BARRIER_PRICER.priceAdjoint(todayFx, strike, timeToExpiry, costOfCarry, rateCounter, volatility, underlyingOption.PutCall.Call, barrier);
if (!option.Rebate.Present)
{
return(valueDerivatives);
}
CurrencyAmount rebate = option.Rebate.get();
ValueDerivatives valueDerivativesRebate = rebate.Currency.Equals(ccyCounter) ? CASH_REBATE_PRICER.priceAdjoint(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType()) : ASSET_REBATE_PRICER.priceAdjoint(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType());
double rebateRate = rebate.Amount / Math.Abs(underlyingFx.BaseCurrencyPayment.Amount);
double price = valueDerivatives.Value + rebateRate * valueDerivativesRebate.Value;
derivatives[0] = valueDerivatives.getDerivative(0) + rebateRate * valueDerivativesRebate.getDerivative(0);
derivatives[1] = valueDerivatives.getDerivative(1);
for (int i = 2; i < 7; ++i)
{
derivatives[i] = valueDerivatives.getDerivative(i) + rebateRate * valueDerivativesRebate.getDerivative(i - 1);
}
return(ValueDerivatives.of(price, DoubleArray.ofUnsafe(derivatives)));
}
/// <summary>
/// Calculates the currency exposure of the foreign exchange vanilla option product.
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the currency exposure </returns>
public virtual MultiCurrencyAmount currencyExposure(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionSmileVolatilities volatilities)
{
validate(ratesProvider, volatilities);
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry <= 0d)
{
return(MultiCurrencyAmount.empty());
}
ResolvedFxSingle underlyingFx = option.Underlying;
Currency ccyCounter = option.CounterCurrency;
double df = ratesProvider.discountFactor(ccyCounter, underlyingFx.PaymentDate);
FxRate forward = fxPricer.forwardFxRate(underlyingFx, ratesProvider);
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
double spot = ratesProvider.fxRate(currencyPair);
double forwardRate = forward.fxRate(currencyPair);
double fwdRateSpotSensitivity = fxPricer.forwardFxRateSpotSensitivity(option.PutCall.Call ? underlyingFx : underlyingFx.inverse(), ratesProvider);
double strikeRate = option.Strike;
bool isCall = option.PutCall.Call;
SmileDeltaParameters smileAtTime = volatilities.Smile.smileForExpiry(timeToExpiry);
double[] strikes = smileAtTime.strike(forwardRate).toArray();
double[] vols = smileAtTime.Volatility.toArray();
double volAtm = vols[1];
double[] x = vannaVolgaWeights(forwardRate, strikeRate, timeToExpiry, volAtm, strikes);
double priceFwd = BlackFormulaRepository.price(forwardRate, strikeRate, timeToExpiry, volAtm, isCall);
double deltaFwd = BlackFormulaRepository.delta(forwardRate, strikeRate, timeToExpiry, volAtm, isCall);
for (int i = 0; i < 3; i += 2)
{
double priceFwdAtm = BlackFormulaRepository.price(forwardRate, strikes[i], timeToExpiry, volAtm, isCall);
double priceFwdSmile = BlackFormulaRepository.price(forwardRate, strikes[i], timeToExpiry, vols[i], isCall);
priceFwd += x[i] * (priceFwdSmile - priceFwdAtm);
double deltaFwdAtm = BlackFormulaRepository.delta(forwardRate, strikes[i], timeToExpiry, volAtm, isCall);
double deltaFwdSmile = BlackFormulaRepository.delta(forwardRate, strikes[i], timeToExpiry, vols[i], isCall);
deltaFwd += x[i] * (deltaFwdSmile - deltaFwdAtm);
}
double price = df * priceFwd;
double delta = df * deltaFwd * fwdRateSpotSensitivity;
double signedNotional = this.signedNotional(option);
CurrencyAmount domestic = CurrencyAmount.of(currencyPair.Counter, (price - delta * spot) * signedNotional);
CurrencyAmount foreign = CurrencyAmount.of(currencyPair.Base, delta * signedNotional);
return(MultiCurrencyAmount.of(domestic, foreign));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the FX barrier option product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of <seealso cref="#presentValue"/> to
/// the underlying curves.
/// </para>
/// <para>
/// The volatility is fixed in this sensitivity computation, i.e., sticky-strike.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value curve sensitivity of the product </returns>
public virtual PointSensitivityBuilder presentValueSensitivityRatesStickyStrike(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
if (volatilities.relativeTime(underlyingOption.Expiry) <= 0d)
{
return(PointSensitivityBuilder.none());
}
ValueDerivatives priceDerivatives = this.priceDerivatives(option, ratesProvider, volatilities);
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
double signedNotional = this.signedNotional(underlyingOption);
double counterYearFraction = ratesProvider.discountFactors(currencyPair.Counter).relativeYearFraction(underlyingFx.PaymentDate);
ZeroRateSensitivity counterSensi = ZeroRateSensitivity.of(currencyPair.Counter, counterYearFraction, signedNotional * (priceDerivatives.getDerivative(2) + priceDerivatives.getDerivative(3)));
double baseYearFraction = ratesProvider.discountFactors(currencyPair.Base).relativeYearFraction(underlyingFx.PaymentDate);
ZeroRateSensitivity baseSensi = ZeroRateSensitivity.of(currencyPair.Base, baseYearFraction, currencyPair.Counter, -priceDerivatives.getDerivative(3) * signedNotional);
return(counterSensi.combinedWith(baseSensi));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the Black theta of the foreign exchange vanilla option product.
/// <para>
/// The theta is the negative of the first derivative of <seealso cref="#price"/> with respect to time parameter
/// in Black formula (the discounted driftless theta).
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the theta of the product </returns>
public virtual double theta(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry <= 0d)
{
return(0d);
}
ResolvedFxSingle underlying = option.Underlying;
FxRate forward = fxPricer.forwardFxRate(underlying, ratesProvider);
CurrencyPair strikePair = underlying.CurrencyPair;
double forwardRate = forward.fxRate(strikePair);
double strikeRate = option.Strike;
double volatility = volatilities.volatility(strikePair, option.Expiry, strikeRate, forwardRate);
double fwdTheta = BlackFormulaRepository.driftlessTheta(forwardRate, strikeRate, timeToExpiry, volatility);
double discountFactor = ratesProvider.discountFactor(option.CounterCurrency, underlying.PaymentDate);
return(discountFactor * fwdTheta);
}
//-------------------------------------------------------------------------
/// <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. This is also called Black vega.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value sensitivity </returns>
public virtual PointSensitivityBuilder presentValueSensitivityModelParamsVolatility(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
if (volatilities.relativeTime(underlyingOption.Expiry) <= 0d)
{
return(PointSensitivityBuilder.none());
}
ValueDerivatives priceDerivatives = this.priceDerivatives(option, ratesProvider, volatilities);
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
Currency ccyBase = currencyPair.Base;
Currency ccyCounter = currencyPair.Counter;
double dfBase = ratesProvider.discountFactor(ccyBase, underlyingFx.PaymentDate);
double dfCounter = ratesProvider.discountFactor(ccyCounter, underlyingFx.PaymentDate);
double todayFx = ratesProvider.fxRate(currencyPair);
double forward = todayFx * dfBase / dfCounter;
return(FxOptionSensitivity.of(volatilities.Name, currencyPair, volatilities.relativeTime(underlyingOption.Expiry), underlyingOption.Strike, forward, ccyCounter, priceDerivatives.getDerivative(4) * signedNotional(underlyingOption)));
}
// the delta without discounting
private double undiscountedDelta(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry < 0d)
{
return(0d);
}
ResolvedFxSingle underlying = option.Underlying;
FxRate forward = fxPricer.forwardFxRate(underlying, ratesProvider);
CurrencyPair strikePair = underlying.CurrencyPair;
double forwardRate = forward.fxRate(strikePair);
double strikeRate = option.Strike;
bool isCall = option.PutCall.Call;
if (timeToExpiry == 0d)
{
return(isCall ? (forwardRate > strikeRate ? 1d : 0d) : (strikeRate > forwardRate ? -1d : 0d));
}
double volatility = volatilities.volatility(strikePair, option.Expiry, strikeRate, forwardRate);
return(BlackFormulaRepository.delta(forwardRate, strikeRate, timeToExpiry, volatility, isCall));
}
/// <summary>
/// Calculates the price of the FX barrier option product.
/// <para>
/// The price of the product is the value on the valuation date for one unit of the base currency
/// and is expressed in the counter currency. The price does not take into account the long/short flag.
/// See <seealso cref="#presentValue"/> for scaling and currency.
/// </para>
/// <para>
/// The volatility used in this computation is the Black implied volatility at expiry time and strike.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the price of the product </returns>
public virtual double price(ResolvedFxSingleBarrierOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
validate(option, ratesProvider, volatilities);
SimpleConstantContinuousBarrier barrier = (SimpleConstantContinuousBarrier)option.Barrier;
ResolvedFxVanillaOption underlyingOption = option.UnderlyingOption;
if (volatilities.relativeTime(underlyingOption.Expiry) < 0d)
{
return(0d);
}
ResolvedFxSingle underlyingFx = underlyingOption.Underlying;
Currency ccyBase = underlyingFx.BaseCurrencyPayment.Currency;
Currency ccyCounter = underlyingFx.CounterCurrencyPayment.Currency;
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
DiscountFactors baseDiscountFactors = ratesProvider.discountFactors(ccyBase);
DiscountFactors counterDiscountFactors = ratesProvider.discountFactors(ccyCounter);
double rateBase = baseDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double rateCounter = counterDiscountFactors.zeroRate(underlyingFx.PaymentDate);
double costOfCarry = rateCounter - rateBase;
double dfBase = baseDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double dfCounter = counterDiscountFactors.discountFactor(underlyingFx.PaymentDate);
double todayFx = ratesProvider.fxRate(currencyPair);
double strike = underlyingOption.Strike;
double forward = todayFx * dfBase / dfCounter;
double volatility = volatilities.volatility(currencyPair, underlyingOption.Expiry, strike, forward);
double timeToExpiry = volatilities.relativeTime(underlyingOption.Expiry);
double price = BARRIER_PRICER.price(todayFx, strike, timeToExpiry, costOfCarry, rateCounter, volatility, underlyingOption.PutCall.Call, barrier);
if (option.Rebate.Present)
{
CurrencyAmount rebate = option.Rebate.get();
double priceRebate = rebate.Currency.Equals(ccyCounter) ? CASH_REBATE_PRICER.price(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType()) : ASSET_REBATE_PRICER.price(todayFx, timeToExpiry, costOfCarry, rateCounter, volatility, barrier.inverseKnockType());
price += priceRebate * rebate.Amount / Math.Abs(underlyingFx.BaseCurrencyPayment.Amount);
}
return(price);
}
/// <summary>
/// Computes the present value sensitivity to the black volatilities used in the pricing.
/// <para>
/// The implied strikes and weights are fixed in this sensitivity computation.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value sensitivity </returns>
public virtual PointSensitivityBuilder presentValueSensitivityModelParamsVolatility(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionSmileVolatilities volatilities)
{
validate(ratesProvider, volatilities);
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry <= 0d)
{
return(PointSensitivityBuilder.none());
}
ResolvedFxSingle underlyingFx = option.Underlying;
Currency ccyCounter = option.CounterCurrency;
double df = ratesProvider.discountFactor(ccyCounter, underlyingFx.PaymentDate);
FxRate forward = fxPricer.forwardFxRate(underlyingFx, ratesProvider);
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
double forwardRate = forward.fxRate(currencyPair);
double strikeRate = option.Strike;
SmileDeltaParameters smileAtTime = volatilities.Smile.smileForExpiry(timeToExpiry);
double[] strikes = smileAtTime.strike(forwardRate).toArray();
double[] vols = smileAtTime.Volatility.toArray();
double volAtm = vols[1];
double[] x = vannaVolgaWeights(forwardRate, strikeRate, timeToExpiry, volAtm, strikes);
double vegaAtm = BlackFormulaRepository.vega(forwardRate, strikeRate, timeToExpiry, volAtm);
double signedNotional = this.signedNotional(option);
PointSensitivityBuilder sensiSmile = PointSensitivityBuilder.none();
for (int i = 0; i < 3; i += 2)
{
double vegaFwdAtm = BlackFormulaRepository.vega(forwardRate, strikes[i], timeToExpiry, volAtm);
vegaAtm -= x[i] * vegaFwdAtm;
double vegaFwdSmile = BlackFormulaRepository.vega(forwardRate, strikes[i], timeToExpiry, vols[i]);
sensiSmile = sensiSmile.combinedWith(FxOptionSensitivity.of(volatilities.Name, currencyPair, timeToExpiry, strikes[i], forwardRate, ccyCounter, df * signedNotional * x[i] * vegaFwdSmile));
}
FxOptionSensitivity sensiAtm = FxOptionSensitivity.of(volatilities.Name, currencyPair, timeToExpiry, strikes[1], forwardRate, ccyCounter, df * signedNotional * vegaAtm);
return(sensiAtm.combinedWith(sensiSmile));
}
/// <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="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value sensitivity </returns>
public virtual PointSensitivityBuilder presentValueSensitivityModelParamsVolatility(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
if (volatilities.relativeTime(option.Expiry) <= 0d)
{
return(PointSensitivityBuilder.none());
}
ResolvedFxSingle underlying = option.Underlying;
FxRate forward = fxPricer.forwardFxRate(underlying, ratesProvider);
CurrencyPair strikePair = underlying.CurrencyPair;
CurrencyAmount valueVega = presentValueVega(option, ratesProvider, volatilities);
return(FxOptionSensitivity.of(volatilities.Name, strikePair, volatilities.relativeTime(option.Expiry), option.Strike, forward.fxRate(strikePair), valueVega.Currency, valueVega.Amount));
}
/// <summary>
/// Calculates the present value vega of the foreign exchange vanilla option product.
/// <para>
/// The present value vega is the first derivative of the <seealso cref="#presentValue"/> with respect to volatility.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value vega of the product </returns>
public virtual CurrencyAmount presentValueVega(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
double vega = this.vega(option, ratesProvider, volatilities);
return(CurrencyAmount.of(option.CounterCurrency, signedNotional(option) * vega));
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value sensitivity of the foreign exchange vanilla option product.
/// <para>
/// The present value sensitivity of the product is the sensitivity of <seealso cref="#presentValue"/> to
/// the underlying curves.
/// </para>
/// <para>
/// The implied strikes and weights are fixed in this sensitivity computation.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value curve sensitivity of the product </returns>
public virtual PointSensitivityBuilder presentValueSensitivityRatesStickyStrike(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionSmileVolatilities volatilities)
{
validate(ratesProvider, volatilities);
double timeToExpiry = volatilities.relativeTime(option.Expiry);
if (timeToExpiry <= 0d)
{
return(PointSensitivityBuilder.none());
}
ResolvedFxSingle underlyingFx = option.Underlying;
Currency ccyCounter = option.CounterCurrency;
double df = ratesProvider.discountFactor(ccyCounter, underlyingFx.PaymentDate);
FxRate forward = fxPricer.forwardFxRate(underlyingFx, ratesProvider);
CurrencyPair currencyPair = underlyingFx.CurrencyPair;
double forwardRate = forward.fxRate(currencyPair);
double strikeRate = option.Strike;
bool isCall = option.PutCall.Call;
SmileDeltaParameters smileAtTime = volatilities.Smile.smileForExpiry(timeToExpiry);
double[] strikes = smileAtTime.strike(forwardRate).toArray();
double[] vols = smileAtTime.Volatility.toArray();
double volAtm = vols[1];
double[] x = vannaVolgaWeights(forwardRate, strikeRate, timeToExpiry, volAtm, strikes);
double priceFwd = BlackFormulaRepository.price(forwardRate, strikeRate, timeToExpiry, volAtm, isCall);
double deltaFwd = BlackFormulaRepository.delta(forwardRate, strikeRate, timeToExpiry, volAtm, isCall);
for (int i = 0; i < 3; i += 2)
{
double priceFwdAtm = BlackFormulaRepository.price(forwardRate, strikes[i], timeToExpiry, volAtm, isCall);
double priceFwdSmile = BlackFormulaRepository.price(forwardRate, strikes[i], timeToExpiry, vols[i], isCall);
priceFwd += x[i] * (priceFwdSmile - priceFwdAtm);
double deltaFwdAtm = BlackFormulaRepository.delta(forwardRate, strikes[i], timeToExpiry, volAtm, isCall);
double deltaFwdSmile = BlackFormulaRepository.delta(forwardRate, strikes[i], timeToExpiry, vols[i], isCall);
deltaFwd += x[i] * (deltaFwdSmile - deltaFwdAtm);
}
double signedNotional = this.signedNotional(option);
PointSensitivityBuilder dfSensi = ratesProvider.discountFactors(ccyCounter).zeroRatePointSensitivity(underlyingFx.PaymentDate).multipliedBy(priceFwd * signedNotional);
PointSensitivityBuilder fwdSensi = fxPricer.forwardFxRatePointSensitivity(option.PutCall.Call ? underlyingFx : underlyingFx.inverse(), ratesProvider).multipliedBy(df * deltaFwd * signedNotional);
return(dfSensi.combinedWith(fwdSensi));
}
// signed notional amount to computed present value and value Greeks
private double signedNotional(ResolvedFxVanillaOption option)
{
return((option.LongShort.Long ? 1d : -1d) * Math.Abs(option.Underlying.BaseCurrencyPayment.Amount));
}
/// <summary>
/// Calculates the present value of the foreign exchange vanilla option product.
/// <para>
/// The present value of the product is the value on the valuation date.
/// It is expressed in the counter currency.
///
/// </para>
/// </summary>
/// <param name="option"> the option product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the present value of the product </returns>
public virtual CurrencyAmount presentValue(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionSmileVolatilities volatilities)
{
double price = this.price(option, ratesProvider, volatilities);
return(CurrencyAmount.of(option.CounterCurrency, signedNotional(option) * price));
}
