public virtual void test_build()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
PointSensitivities test = @base.build();
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
public virtual void test_cloned()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity test = @base.cloned();
assertSame(test, @base);
}
public virtual void test_compareExcludingSensitivity()
{
FxOptionSensitivity a1 = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity a2 = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity b = FxOptionSensitivity.of(NAME, CurrencyPair.of(EUR, USD), EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity c = FxOptionSensitivity.of(NAME, PAIR, EXPIRY + 1, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity d = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, 0.96, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity e = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, 0.81, GBP, SENSI_VALUE);
FxOptionSensitivity f = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, EUR, SENSI_VALUE);
ZeroRateSensitivity other = ZeroRateSensitivity.of(GBP, 2d, 32d);
assertEquals(a1.compareKey(a2), 0);
assertEquals(a1.compareKey(b) < 0, true);
assertEquals(b.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(c) < 0, true);
assertEquals(c.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(d) < 0, true);
assertEquals(d.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(e) < 0, true);
assertEquals(e.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(f) > 0, true);
assertEquals(f.compareKey(a1) < 0, true);
assertEquals(a1.compareKey(other) < 0, true);
assertEquals(other.compareKey(a1) > 0, true);
}
public virtual void test_mapSensitivity()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity expected = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, 1.0 / SENSI_VALUE);
FxOptionSensitivity test = @base.mapSensitivity(s => 1 / s);
assertEquals(test, expected);
}
public virtual void test_buildInto()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
MutablePointSensitivities combo = new MutablePointSensitivities();
MutablePointSensitivities test = @base.buildInto(combo);
assertSame(test, combo);
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
public virtual void coverage()
{
FxOptionSensitivity test1 = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
coverImmutableBean(test1);
FxOptionSensitivity test2 = FxOptionSensitivity.of(NAME2, CurrencyPair.of(EUR, USD), EXPIRY, 0.8, 0.9, EUR, 1.1);
coverBeanEquals(test1, test2);
}
public virtual void test_multipliedBy()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
double factor = 5.2d;
FxOptionSensitivity expected = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE * factor);
FxOptionSensitivity test = @base.multipliedBy(factor);
assertEquals(test, expected);
}
public virtual void test_of()
{
FxOptionSensitivity test = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
assertEquals(test.Currency, GBP);
assertEquals(test.Expiry, EXPIRY);
assertEquals(test.Forward, FORWARD);
assertEquals(test.CurrencyPair, PAIR);
assertEquals(test.Sensitivity, SENSI_VALUE);
assertEquals(test.Strike, STRIKE);
}
public virtual void test_withSensitivity()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
double newSensi = 22.5;
FxOptionSensitivity test = @base.withSensitivity(newSensi);
assertEquals(test.Currency, GBP);
assertEquals(test.Expiry, EXPIRY);
assertEquals(test.Forward, FORWARD);
assertEquals(test.CurrencyPair, PAIR);
assertEquals(test.Sensitivity, newSensi);
assertEquals(test.Strike, STRIKE);
}
/// <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));
}
//-------------------------------------------------------------------------
public virtual void test_presentValueSensitivityBlackVolatility()
{
FxOptionSensitivity computedCall = (FxOptionSensitivity)PRICER.presentValueSensitivityModelParamsVolatility(CALL_OTM, RATES_PROVIDER, VOLS);
FxOptionSensitivity computedPut = (FxOptionSensitivity)PRICER.presentValueSensitivityModelParamsVolatility(PUT_ITM, RATES_PROVIDER, VOLS);
double timeToExpiry = VOLS.relativeTime(EXPIRY);
double df = RATES_PROVIDER.discountFactor(USD, PAYMENT_DATE);
double forward = PRICER.DiscountingFxSingleProductPricer.forwardFxRate(FX_PRODUCT_HIGH, RATES_PROVIDER).fxRate(CURRENCY_PAIR);
double vol = SMILE_TERM.volatility(timeToExpiry, STRIKE_RATE_HIGH, forward);
FxOptionSensitivity expected = FxOptionSensitivity.of(VOLS.Name, CURRENCY_PAIR, timeToExpiry, STRIKE_RATE_HIGH, forward, USD, -NOTIONAL * df * BlackFormulaRepository.vega(forward, STRIKE_RATE_HIGH, timeToExpiry, vol));
assertTrue(computedCall.build().equalWithTolerance(expected.build(), NOTIONAL * TOL));
assertTrue(computedPut.build().equalWithTolerance(expected.build().multipliedBy(-1d), NOTIONAL * TOL));
}
public virtual void test_withCurrency()
{
FxOptionSensitivity @base = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
FxOptionSensitivity test1 = @base.withCurrency(EUR);
assertEquals(test1.Currency, EUR);
assertEquals(test1.Expiry, EXPIRY);
assertEquals(test1.Forward, FORWARD);
assertEquals(test1.CurrencyPair, PAIR);
assertEquals(test1.Sensitivity, SENSI_VALUE);
assertEquals(test1.Strike, STRIKE);
FxOptionSensitivity test2 = @base.withCurrency(GBP);
assertEquals(test2, @base);
}
public virtual void test_parameterSensitivity_inverse()
{
for (int i = 0; i < NB_EXPIRY; i++)
{
for (int j = 0; j < NB_STRIKE; ++j)
{
double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]);
FxOptionSensitivity sensi = FxOptionSensitivity.of(VOLS.Name, CURRENCY_PAIR.inverse(), timeToExpiry, 1d / TEST_STRIKE[j], 1d / FORWARD[i], GBP, 1d);
CurrencyParameterSensitivities computed = VOLS.parameterSensitivity(sensi);
for (int k = 0; k < TIMES.size(); k++)
{
double value = computed.Sensitivities.get(0).Sensitivity.get(k);
double nodeExpiry = TIMES.get(k);
double expected = nodeSensitivity(VOLS, CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i], nodeExpiry);
assertEquals(value, expected, EPS);
}
}
}
}
//-------------------------------------------------------------------------
/// <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)));
}
//-------------------------------------------------------------------------
public virtual void test_nodeSensitivity()
{
for (int i = 0; i < NB_EXPIRY; i++)
{
for (int j = 0; j < NB_STRIKE; ++j)
{
double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]);
FxOptionSensitivity sensi = FxOptionSensitivity.of(VOLS.Name, CURRENCY_PAIR, timeToExpiry, TEST_STRIKE[j], FORWARD[i], GBP, 1d);
CurrencyParameterSensitivities computed = VOLS.parameterSensitivity(sensi);
for (int k = 0; k < SURFACE.ParameterCount; k++)
{
double value = computed.Sensitivities.get(0).Sensitivity.get(k);
double nodeExpiry = SURFACE.XValues.get(k);
double nodeStrike = SURFACE.YValues.get(k);
double expected = nodeSensitivity(VOLS, CURRENCY_PAIR, TEST_EXPIRY[i], TEST_STRIKE[j], FORWARD[i], nodeExpiry, nodeStrike);
assertEquals(value, expected, EPS);
}
}
}
}
public virtual void test_surfaceParameterSensitivity_inverse()
{
for (int i = 0; i < NB_EXPIRY; i++)
{
for (int j = 0; j < NB_STRIKE; ++j)
{
double timeToExpiry = VOLS.relativeTime(TEST_EXPIRY[i]);
FxOptionSensitivity sensi = FxOptionSensitivity.of(VOLS.Name, CURRENCY_PAIR.inverse(), timeToExpiry, 1d / TEST_STRIKE[j], 1d / FORWARD[i], GBP, 1d);
CurrencyParameterSensitivity computed = VOLS.parameterSensitivity(sensi).Sensitivities.get(0);
IEnumerator <ParameterMetadata> itr = computed.ParameterMetadata.GetEnumerator();
foreach (double value in computed.Sensitivity.toArray())
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
FxVolatilitySurfaceYearFractionParameterMetadata meta = ((FxVolatilitySurfaceYearFractionParameterMetadata)itr.next());
double nodeExpiry = meta.YearFraction;
double nodeDelta = meta.Strike.Value;
double expected = nodeSensitivity(VOLS, CURRENCY_PAIR.inverse(), TEST_EXPIRY[i], 1d / TEST_STRIKE[j], 1d / FORWARD[i], nodeExpiry, nodeDelta);
assertEquals(value, expected, EPS);
}
}
}
}
/// <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));
}
public virtual void test_serialization()
{
FxOptionSensitivity test = FxOptionSensitivity.of(NAME, PAIR, EXPIRY, STRIKE, FORWARD, GBP, SENSI_VALUE);
assertSerialization(test);
}
