public virtual void test_currencyExposureOnFixing_noTimeSeries()
{
double eps = 1.0e-14;
LocalDate valuationDate = date(2014, 6, 27);
LocalDate paymentDate = date(2014, 7, 1);
LocalDate fixingDate = date(2014, 6, 27);
FxResetNotionalExchange resetNotionalUSD = FxResetNotionalExchange.of(CurrencyAmount.of(USD, NOTIONAL), paymentDate, FxIndexObservation.of(GBP_USD_WM, fixingDate, REF_DATA));
FxResetNotionalExchange resetNotionalGBP = FxResetNotionalExchange.of(CurrencyAmount.of(GBP, -NOTIONAL), paymentDate, FxIndexObservation.of(GBP_USD_WM, fixingDate, REF_DATA));
ImmutableRatesProvider prov = ImmutableRatesProvider.builder(valuationDate).fxRateProvider(FX_MATRIX).discountCurve(GBP, DISCOUNT_CURVE_GBP).discountCurve(USD, DISCOUNT_CURVE_USD).build();
DiscountingFxResetNotionalExchangePricer test = new DiscountingFxResetNotionalExchangePricer();
// USD
MultiCurrencyAmount computedUSD = test.currencyExposure(resetNotionalUSD, prov);
PointSensitivities pointUSD = test.presentValueSensitivity(resetNotionalUSD, prov).build();
MultiCurrencyAmount expectedUSD = prov.currencyExposure(pointUSD.convertedTo(USD, prov)).plus(CurrencyAmount.of(resetNotionalUSD.Currency, test.presentValue(resetNotionalUSD, prov)));
assertFalse(computedUSD.contains(GBP)); // 0 GBP
assertEquals(computedUSD.getAmount(USD).Amount, expectedUSD.getAmount(USD).Amount, eps * NOTIONAL);
// GBP
MultiCurrencyAmount computedGBP = test.currencyExposure(resetNotionalGBP, prov);
PointSensitivities pointGBP = test.presentValueSensitivity(resetNotionalGBP, prov).build();
MultiCurrencyAmount expectedGBP = prov.currencyExposure(pointGBP.convertedTo(GBP, prov)).plus(CurrencyAmount.of(resetNotionalGBP.Currency, test.presentValue(resetNotionalGBP, prov)));
assertFalse(computedGBP.contains(USD)); // 0 USD
assertEquals(computedGBP.getAmount(GBP).Amount, expectedGBP.getAmount(GBP).Amount, eps * NOTIONAL);
// FD approximation
FxMatrix fxMatrixUp = FxMatrix.of(GBP, USD, FX_RATE + EPS_FD);
ImmutableRatesProvider provUp = ImmutableRatesProvider.builder(valuationDate).fxRateProvider(fxMatrixUp).discountCurve(GBP, DISCOUNT_CURVE_GBP).discountCurve(USD, DISCOUNT_CURVE_USD).build();
double expectedFdUSD = -(test.presentValue(resetNotionalUSD, provUp) - test.presentValue(resetNotionalUSD, prov)) * FX_RATE * FX_RATE / EPS_FD;
assertEquals(computedUSD.getAmount(USD).Amount, expectedFdUSD, EPS_FD * NOTIONAL);
double expectedFdGBP = (test.presentValue(resetNotionalGBP, provUp) - test.presentValue(resetNotionalGBP, prov)) / EPS_FD;
assertEquals(computedGBP.getAmount(GBP).Amount, expectedFdGBP, EPS_FD * NOTIONAL);
}
public virtual void coverage()
{
coverImmutableBean(VALUES_ARRAY);
MultiCurrencyScenarioArray test2 = MultiCurrencyScenarioArray.of(MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 21), CurrencyAmount.of(Currency.USD, 31), CurrencyAmount.of(Currency.EUR, 41)), MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 22), CurrencyAmount.of(Currency.USD, 33), CurrencyAmount.of(Currency.EUR, 44)));
coverBeanEquals(VALUES_ARRAY, test2);
}
//-------------------------------------------------------------------------
public virtual void test_currencyExposure()
{
MultiCurrencyAmount ceComputed = OPTION_TRADE_PRICER.currencyExposure(OPTION_TRADE, RATE_PROVIDER, VOLS, REFERENCE_PRICE);
CurrencyAmount pv = OPTION_TRADE_PRICER.presentValue(OPTION_TRADE, RATE_PROVIDER, VOLS, REFERENCE_PRICE);
assertEquals(ceComputed, MultiCurrencyAmount.of(pv));
}
//-------------------------------------------------------------------------
public virtual void calibration_present_value()
{
RatesProvider result2 = CALIBRATOR.calibrate(CURVE_GROUP_DEFN, ALL_QUOTES, REF_DATA);
// Test PV
CurveNode[] fwd3Nodes = CURVES_NODES[0][0];
IList <ResolvedTrade> fwd3Trades = new List <ResolvedTrade>();
for (int i = 0; i < fwd3Nodes.Length; i++)
{
fwd3Trades.Add(fwd3Nodes[i].resolvedTrade(1d, ALL_QUOTES, REF_DATA));
}
// Fixing
CurrencyAmount pvFixing2 = FIXING_PRICER.presentValue(((ResolvedIborFixingDepositTrade)fwd3Trades[0]).Product, result2);
assertEquals(pvFixing2.Amount, 0.0, TOLERANCE_PV);
// FRA
for (int i = 0; i < FWD3_NB_FRA_NODES; i++)
{
CurrencyAmount pvFra2 = FRA_PRICER.presentValue(((ResolvedFraTrade)fwd3Trades[i + 1]), result2);
assertEquals(pvFra2.Amount, 0.0, TOLERANCE_PV);
}
// IRS
for (int i = 0; i < FWD3_NB_IRS_NODES; i++)
{
MultiCurrencyAmount pvIrs2 = SWAP_PRICER.presentValue(((ResolvedSwapTrade)fwd3Trades[i + 1 + FWD3_NB_FRA_NODES]).Product, result2);
assertEquals(pvIrs2.getAmount(USD).Amount, 0.0, TOLERANCE_PV);
}
}
//-------------------------------------------------------------------------
public virtual void currency_exposure()
{
CurrencyAmount pv = PRICER_SWAPTION_BLACK.presentValue(SWAPTION_LONG_PAY, MULTI_USD, BLACK_VOLS_USD_STD);
MultiCurrencyAmount ce = PRICER_SWAPTION_BLACK.currencyExposure(SWAPTION_LONG_PAY, MULTI_USD, BLACK_VOLS_USD_STD);
assertEquals(pv.Amount, ce.getAmount(USD).Amount, TOLERANCE_PV);
}
//-------------------------------------------------------------------------
public virtual void calibration_test()
{
RatesProvider result2 = CALIBRATOR.calibrate(CURVE_GROUP_DEFN, ALL_QUOTES, REF_DATA);
// pv test
CurveNode[] fwd3Nodes = CURVES_NODES[0][0];
IList <ResolvedTrade> fwd3Trades = new List <ResolvedTrade>();
for (int i = 0; i < fwd3Nodes.Length; i++)
{
fwd3Trades.Add(fwd3Nodes[i].resolvedTrade(1d, ALL_QUOTES, REF_DATA));
}
for (int i = 0; i < FWD6_NB_NODES; i++)
{
MultiCurrencyAmount pvIrs2 = SWAP_PRICER.presentValue(((ResolvedSwapTrade)fwd3Trades[i]).Product, result2);
assertEquals(pvIrs2.getAmount(GBP).Amount, 0.0, TOLERANCE_PV);
}
// regression test for curve
DiscountFactors dsc = result2.discountFactors(GBP);
double prevDsc = 0d;
for (int i = 0; i < 121; ++i)
{
double time = ((double)i);
double curDsc = dsc.discountFactor(time);
if (i > 59)
{
double fwd = prevDsc / curDsc - 1d;
assertEquals(fwd, 0.042, 2d * ONE_BP);
}
assertEquals(curDsc, DSC_EXP.get(i), ONE_PC);
prevDsc = curDsc;
}
}
private void assertPresentValue(RatesProvider result)
{
// Test PV USD;
IList <ResolvedTrade> usdTrades = new List <ResolvedTrade>();
for (int i = 0; i < USD_DSC_NODES.Length; i++)
{
usdTrades.Add(USD_DSC_NODES[i].resolvedTrade(1d, ALL_QUOTES, REF_DATA));
}
// Depo
for (int i = 0; i < USD_DSC_NB_DEPO_NODES; i++)
{
CurrencyAmount pvDep = DEPO_PRICER.presentValue(((ResolvedTermDepositTrade)usdTrades[i]).Product, result);
assertEquals(pvDep.Amount, 0.0, TOLERANCE_PV);
}
// OIS
for (int i = 0; i < USD_DSC_NB_OIS_NODES; i++)
{
MultiCurrencyAmount pvOis = SWAP_PRICER.presentValue(((ResolvedSwapTrade)usdTrades[USD_DSC_NB_DEPO_NODES + i]).Product, result);
assertEquals(pvOis.getAmount(USD).Amount, 0.0, TOLERANCE_PV);
}
// Test PV EUR;
IList <ResolvedTrade> eurTrades = new List <ResolvedTrade>();
for (int i = 0; i < EUR_DSC_NODES.Length; i++)
{
eurTrades.Add(EUR_DSC_NODES[i].resolvedTrade(1d, ALL_QUOTES, REF_DATA));
}
// Depo
for (int i = 0; i < EUR_DSC_NB_FX_NODES; i++)
{
MultiCurrencyAmount pvFx = FX_PRICER.presentValue(((ResolvedFxSwapTrade)eurTrades[i]).Product, result);
assertEquals(pvFx.convertedTo(USD, result).Amount, 0.0, TOLERANCE_PV);
}
}
//-------------------------------------------------------------------------
public virtual void test_currencyExposure()
{
double eps = 1.0e-14;
ImmutableRatesProvider prov = ImmutableRatesProvider.builder(VAL_DATE).fxRateProvider(FX_MATRIX).discountCurve(GBP, DISCOUNT_CURVE_GBP).discountCurve(USD, DISCOUNT_CURVE_USD).build();
DiscountingFxResetNotionalExchangePricer test = new DiscountingFxResetNotionalExchangePricer();
// USD
MultiCurrencyAmount computedUSD = test.currencyExposure(FX_RESET_NOTIONAL_EXCHANGE_REC_USD, prov);
PointSensitivities pointUSD = test.presentValueSensitivity(FX_RESET_NOTIONAL_EXCHANGE_REC_USD, prov).build();
MultiCurrencyAmount expectedUSD = prov.currencyExposure(pointUSD.convertedTo(USD, prov)).plus(CurrencyAmount.of(FX_RESET_NOTIONAL_EXCHANGE_REC_USD.Currency, test.presentValue(FX_RESET_NOTIONAL_EXCHANGE_REC_USD, prov)));
assertFalse(computedUSD.contains(GBP)); // 0 GBP
assertEquals(computedUSD.getAmount(USD).Amount, expectedUSD.getAmount(USD).Amount, eps * NOTIONAL);
// GBP
MultiCurrencyAmount computedGBP = test.currencyExposure(FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP, prov);
PointSensitivities pointGBP = test.presentValueSensitivity(FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP, prov).build();
MultiCurrencyAmount expectedGBP = prov.currencyExposure(pointGBP.convertedTo(GBP, prov)).plus(CurrencyAmount.of(FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP.Currency, test.presentValue(FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP, prov)));
assertFalse(computedGBP.contains(USD)); // 0 USD
assertEquals(computedGBP.getAmount(GBP).Amount, expectedGBP.getAmount(GBP).Amount, eps * NOTIONAL);
// FD approximation
FxMatrix fxMatrixUp = FxMatrix.of(GBP, USD, FX_RATE + EPS_FD);
ImmutableRatesProvider provUp = ImmutableRatesProvider.builder(VAL_DATE).fxRateProvider(fxMatrixUp).discountCurve(GBP, DISCOUNT_CURVE_GBP).discountCurve(USD, DISCOUNT_CURVE_USD).build();
double expectedFdUSD = -(test.presentValue(FX_RESET_NOTIONAL_EXCHANGE_REC_USD, provUp) - test.presentValue(FX_RESET_NOTIONAL_EXCHANGE_REC_USD, prov)) * FX_RATE * FX_RATE / EPS_FD;
assertEquals(computedUSD.getAmount(USD).Amount, expectedFdUSD, EPS_FD * NOTIONAL);
double expectedFdGBP = (test.presentValue(FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP, provUp) - test.presentValue(FX_RESET_NOTIONAL_EXCHANGE_PAY_GBP, prov)) / EPS_FD;
assertEquals(computedGBP.getAmount(GBP).Amount, expectedFdGBP, EPS_FD * NOTIONAL);
}
private void checkSwapPvIsZero(FixedIborSwapCurveNode node, RatesProvider ratesProvider, MarketData marketDataMap)
{
ResolvedSwapTrade trade = node.resolvedTrade(1d, marketDataMap, REF_DATA);
MultiCurrencyAmount amount = DiscountingSwapTradePricer.DEFAULT.presentValue(trade, ratesProvider);
double pv = amount.getAmount(Currency.USD).Amount;
assertThat(pv).isCloseTo(0, offset(PV_TOLERANCE));
}
public virtual void emptyAmounts()
{
MultiCurrencyScenarioArray array = MultiCurrencyScenarioArray.of(MultiCurrencyAmount.empty(), MultiCurrencyAmount.empty());
assertThat(array.ScenarioCount).isEqualTo(2);
assertThat(array.get(0)).isEqualTo(MultiCurrencyAmount.empty());
assertThat(array.get(1)).isEqualTo(MultiCurrencyAmount.empty());
}
public virtual void get()
{
MultiCurrencyAmount expected = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 22), CurrencyAmount.of(Currency.USD, 33), CurrencyAmount.of(Currency.EUR, 44));
assertThat(VALUES_ARRAY.get(2)).isEqualTo(expected);
assertThrows(() => VALUES_ARRAY.get(3), typeof(System.IndexOutOfRangeException));
assertThrows(() => VALUES_ARRAY.get(-1), typeof(System.IndexOutOfRangeException));
}
public virtual void present_value_payer_receiver_parity()
{
CurrencyAmount pvLongPay = PRICER_SWAPTION_BLACK.presentValue(SWAPTION_LONG_PAY, MULTI_USD, BLACK_VOLS_USD_STD);
CurrencyAmount pvShortRec = PRICER_SWAPTION_BLACK.presentValue(SWAPTION_SHORT_REC, MULTI_USD, BLACK_VOLS_USD_STD);
MultiCurrencyAmount pvSwapPay = PRICER_SWAP.presentValue(RSWAP_PAY, MULTI_USD);
assertEquals(pvLongPay.Amount + pvShortRec.Amount, pvSwapPay.getAmount(USD).Amount, TOLERANCE_PV);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the accrued interest since the last payment.
/// <para>
/// This determines the payment period applicable at the valuation date and calculates
/// the accrued interest since the last payment.
///
/// </para>
/// </summary>
/// <param name="swap"> the product </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the accrued interest of the swap product </returns>
public virtual MultiCurrencyAmount accruedInterest(ResolvedSwap swap, RatesProvider provider)
{
MultiCurrencyAmount result = MultiCurrencyAmount.empty();
foreach (ResolvedSwapLeg leg in swap.Legs)
{
result = result.plus(legPricer.accruedInterest(leg, provider));
}
return(result);
}
/// <summary>
/// Exports a <seealso cref="MultiCurrencyAmount"/> to a csv file.
/// </summary>
/// <param name="multiCurrencyAmount"> the amount </param>
/// <param name="fileName"> the file name </param>
public static void export(MultiCurrencyAmount multiCurrencyAmount, string fileName)
{
StringBuilder builder = new StringBuilder();
foreach (CurrencyAmount ca in multiCurrencyAmount.Amounts)
{
builder.Append(ca.Currency.ToString()).Append(',').Append(ca.Amount).Append(',');
}
export(builder.ToString(), fileName);
}
/// <summary>
/// Calculates the current cash of the swap product.
/// </summary>
/// <param name="swap"> the product </param>
/// <param name="provider"> the rates provider </param>
/// <returns> the current cash of the swap product </returns>
public virtual MultiCurrencyAmount currentCash(ResolvedSwap swap, RatesProvider provider)
{
MultiCurrencyAmount ce = MultiCurrencyAmount.empty();
foreach (ResolvedSwapLeg leg in swap.Legs)
{
ce = ce.plus(legPricer.currentCash(leg, provider));
}
return(ce);
}
//-------------------------------------------------------------------------
public virtual void test_currencyExposure()
{
ImmutableRatesProvider prov = ImmutableRatesProvider.builder(VAL_DATE).discountCurve(GBP, DISCOUNT_CURVE_GBP).build();
DiscountingNotionalExchangePricer test = DiscountingNotionalExchangePricer.DEFAULT;
MultiCurrencyAmount computed = test.currencyExposure(NOTIONAL_EXCHANGE_REC_GBP, prov);
PointSensitivities point = test.presentValueSensitivity(NOTIONAL_EXCHANGE_REC_GBP, prov).build();
MultiCurrencyAmount expected = prov.currencyExposure(point).plus(CurrencyAmount.of(NOTIONAL_EXCHANGE_REC_GBP.Currency, test.presentValue(NOTIONAL_EXCHANGE_REC_GBP, prov)));
assertEquals(computed, expected);
}
public virtual void test_currencyExposure_after_expiry()
{
MultiCurrencyAmount computedRec = PRICER_SWAPTION.currencyExposure(SWAPTION_REC_LONG_PAST, RATE_PROVIDER, VOLS);
MultiCurrencyAmount computedPay = PRICER_SWAPTION.currencyExposure(SWAPTION_PAY_SHORT_PAST, RATE_PROVIDER, VOLS);
assertEquals(computedRec.size(), 1);
assertEquals(computedRec.getAmount(USD).Amount, 0d, NOTIONAL * TOL);
assertEquals(computedPay.size(), 1);
assertEquals(computedPay.getAmount(USD).Amount, 0d, NOTIONAL * TOL);
}
public virtual void toMultiCurrencyArray()
{
IList <MultiCurrencyAmount> amounts = ImmutableList.of(MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 20), CurrencyAmount.of(Currency.USD, 30), CurrencyAmount.of(Currency.EUR, 40)), MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 21), CurrencyAmount.of(Currency.USD, 32), CurrencyAmount.of(Currency.EUR, 43)), MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 22), CurrencyAmount.of(Currency.USD, 33), CurrencyAmount.of(Currency.EUR, 44)));
MultiCurrencyScenarioArray expected = MultiCurrencyScenarioArray.of(amounts);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
MultiCurrencyScenarioArray array = amounts.collect(FunctionUtils.toMultiCurrencyValuesArray());
assertThat(array).isEqualTo(expected);
}
public virtual void test_currencyExposure_afterMaturity()
{
MultiCurrencyAmount computedRec = PRICER.currencyExposure(SWAPTION_REC_LONG, RATES_PROVIDER_AFTER_MATURITY, VOLS_AFTER_MATURITY);
MultiCurrencyAmount computedPay = PRICER.currencyExposure(SWAPTION_PAY_SHORT, RATES_PROVIDER_AFTER_MATURITY, VOLS_AFTER_MATURITY);
assertEquals(computedRec.size(), 1);
assertEquals(computedRec.getAmount(EUR).Amount, 0d, NOTIONAL * TOL);
assertEquals(computedPay.size(), 1);
assertEquals(computedPay.getAmount(EUR).Amount, 0d, NOTIONAL * TOL);
}
public virtual void toScenarioArray2()
{
IList <MultiCurrencyAmount> amounts = ImmutableList.of(MultiCurrencyAmount.of(Currency.GBP, 1), MultiCurrencyAmount.of(CurrencyAmount.of(Currency.USD, 2), CurrencyAmount.of(Currency.GBP, 3)));
ScenarioArray <MultiCurrencyAmount> expectedResult = ScenarioArray.of(amounts);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
ScenarioArray <MultiCurrencyAmount> result = amounts.collect(FunctionUtils.toScenarioArray());
assertThat(result).isEqualTo(expectedResult);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calculates the present value of the CMS product.
/// <para>
/// The present value of the product is the value on the valuation date.
/// </para>
/// <para>
/// CMS leg and pay leg are typically in the same currency. Thus the present value is expressed as a
/// single currency amount in most cases.
///
/// </para>
/// </summary>
/// <param name="cms"> the CMS product </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="swaptionVolatilities"> the swaption volatilities </param>
/// <returns> the present value </returns>
public virtual MultiCurrencyAmount presentValue(ResolvedCms cms, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities)
{
CurrencyAmount pvCmsLeg = cmsLegPricer.presentValue(cms.CmsLeg, ratesProvider, swaptionVolatilities);
if (!cms.PayLeg.Present)
{
return(MultiCurrencyAmount.of(pvCmsLeg));
}
CurrencyAmount pvPayLeg = payLegPricer.presentValue(cms.PayLeg.get(), ratesProvider);
return(MultiCurrencyAmount.of(pvCmsLeg).plus(pvPayLeg));
}
//-------------------------------------------------------------------------
/// <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));
}
public virtual void test_simpleMeasures()
{
BondFutureOptionTradeCalculationFunction <BondFutureOptionTrade> function = BondFutureOptionTradeCalculationFunction.TRADE;
ScenarioMarketData md = marketData();
LegalEntityDiscountingProvider provider = LED_LOOKUP.marketDataView(md.scenario(0)).discountingProvider();
BlackBondFutureOptionMarginedTradePricer pricer = BlackBondFutureOptionMarginedTradePricer.DEFAULT;
CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, VOLS, SETTLE_PRICE);
MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, VOLS, SETTLE_PRICE);
ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.CURRENCY_EXPOSURE, Measures.RESOLVED_TARGET);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RTRADE));
}
private MultiCurrencyAmount currencyExposureEventsInternal(ResolvedSwapLeg leg, RatesProvider provider)
{
MultiCurrencyAmount total = MultiCurrencyAmount.empty();
foreach (SwapPaymentEvent @event in leg.PaymentEvents)
{
if ([email protected](provider.ValuationDate))
{
total = total.plus(paymentEventPricer.currencyExposure(@event, provider));
}
}
return(total);
}
public virtual void test_simpleMeasures()
{
CmsTradeCalculationFunction function = new CmsTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
SabrExtrapolationReplicationCmsTradePricer pricer = new SabrExtrapolationReplicationCmsTradePricer(new SabrExtrapolationReplicationCmsProductPricer(new SabrExtrapolationReplicationCmsLegPricer(SabrExtrapolationReplicationCmsPeriodPricer.of(CUT_OFF_STRIKE, MU))));
ResolvedCmsTrade resolved = TRADE.resolve(REF_DATA);
MultiCurrencyAmount expectedPv = pricer.presentValue(resolved, provider, VOLS);
ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.RESOLVED_TARGET);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(TRADE.resolve(REF_DATA)));
}
public virtual void createByFunction()
{
MultiCurrencyAmount mca1 = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 10), CurrencyAmount.of(Currency.USD, 20));
MultiCurrencyAmount mca2 = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 10), CurrencyAmount.of(Currency.EUR, 30));
MultiCurrencyAmount mca3 = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.USD, 40));
IList <MultiCurrencyAmount> amounts = ImmutableList.of(mca1, mca2, mca3);
MultiCurrencyScenarioArray test = MultiCurrencyScenarioArray.of(3, i => amounts[i]);
assertThat(test.get(0)).isEqualTo(mca1.plus(Currency.EUR, 0));
assertThat(test.get(1)).isEqualTo(mca2.plus(Currency.USD, 0));
assertThat(test.get(2)).isEqualTo(mca3.plus(Currency.GBP, 0).plus(Currency.EUR, 0));
}
/// <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));
}
public virtual void test_simpleMeasures()
{
FxVanillaOptionTradeCalculationFunction function = new FxVanillaOptionTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
BlackFxVanillaOptionTradePricer pricer = BlackFxVanillaOptionTradePricer.DEFAULT;
MultiCurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, VOLS);
MultiCurrencyAmount expectedCurrencyExp = pricer.currencyExposure(RTRADE, provider, VOLS);
CurrencyAmount expectedCash = pricer.currentCash(RTRADE, VAL_DATE);
ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.PAR_SPREAD, Measures.CURRENCY_EXPOSURE, Measures.CURRENT_CASH, Measures.RESOLVED_TARGET);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExp)))).containsEntry(Measures.CURRENT_CASH, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedCash)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RTRADE));
}
public virtual void test_simpleMeasures()
{
DsfTradeCalculationFunction <DsfTrade> function = DsfTradeCalculationFunction.TRADE;
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
DiscountingDsfTradePricer pricer = DiscountingDsfTradePricer.DEFAULT;
double expectedPrice = pricer.price(RTRADE, provider);
CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, REF_PRICE);
MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, REF_PRICE);
ISet <Measure> measures = ImmutableSet.of(Measures.UNIT_PRICE, Measures.PRESENT_VALUE, Measures.CURRENCY_EXPOSURE, Measures.RESOLVED_TARGET);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.UNIT_PRICE, Result.success(DoubleScenarioArray.of(ImmutableList.of(expectedPrice)))).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RTRADE));
}
public virtual void test_simpleMeasures()
{
IborCapFloorTradeCalculationFunction function = new IborCapFloorTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
NormalIborCapFloorTradePricer pricer = NormalIborCapFloorTradePricer.DEFAULT;
MultiCurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, VOLS);
MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, VOLS);
MultiCurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider, VOLS);
ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.CURRENCY_EXPOSURE, Measures.CURRENT_CASH);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure)))).containsEntry(Measures.CURRENT_CASH, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))));
}
