//-------------------------------------------------------------------------
public virtual void coverage()
{
FxForwardSensitivity test1 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
coverImmutableBean(test1);
FxForwardSensitivity test2 = FxForwardSensitivity.of(CurrencyPair.of(USD, JPY), JPY, date(2015, 9, 27), 4.25d);
coverBeanEquals(test1, test2);
}
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_forwardFxRatePointSensitivity()
{
PointSensitivityBuilder computed = PRICER.forwardFxRatePointSensitivity(FWD, PROVIDER);
FxForwardSensitivity expected = FxForwardSensitivity.of(CurrencyPair.of(USD, KRW), USD, FWD.PaymentDate, 1d);
assertEquals(computed, expected);
}
//-------------------------------------------------------------------------
/// <summary>
/// Calibrate trinomial tree to Black volatilities by using a vanilla option.
/// <para>
/// {@code ResolvedFxVanillaOption} is typically the underlying option of an exotic instrument to price using the
/// calibrated tree, and is used to ensure that the grid points properly cover the lifetime of the target option.
///
/// </para>
/// </summary>
/// <param name="option"> the vanilla option </param>
/// <param name="ratesProvider"> the rates provider </param>
/// <param name="volatilities"> the Black volatility provider </param>
/// <returns> the trinomial tree data </returns>
public virtual RecombiningTrinomialTreeData calibrateTrinomialTree(ResolvedFxVanillaOption option, RatesProvider ratesProvider, BlackFxOptionVolatilities volatilities)
{
double timeToExpiry = volatilities.relativeTime(option.Expiry);
CurrencyPair currencyPair = option.Underlying.CurrencyPair;
return(calibrateTrinomialTree(timeToExpiry, currencyPair, ratesProvider, volatilities));
}
public virtual void coverage_builder()
{
MetaBean meta = MetaBean.of(typeof(FxRateId));
Bean test1 = meta.builder().set("pair", CurrencyPair.parse("EUR/GBP")).set("observableSource", OBS_SOURCE).build();
Bean test2 = meta.builder().set("pair", CurrencyPair.parse("EUR/GBP")).set("observableSource", OBS_SOURCE).build();
coverBeanEquals(test1, test2);
}
//-------------------------------------------------------------------------
public virtual void test_toFxForwardSensitivity()
{
FxIndexSensitivity test = FxIndexSensitivity.of(GBP_USD_WM_OBS, GBP, USD, SENSITIVITY_VALUE);
LocalDate maturityDate = GBP_USD_WM.calculateMaturityFromFixing(FIXING_DATE, REF_DATA);
FxForwardSensitivity expected = FxForwardSensitivity.of(CurrencyPair.of(GBP, USD), GBP, maturityDate, USD, SENSITIVITY_VALUE);
assertEquals(test.toFxForwardSensitivity(), expected);
}
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 coverage()
{
FxOptionVolatilitiesNode test1 = FxOptionVolatilitiesNode.of(EUR_GBP, SPOT_DATE_OFFSET, BDA, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_3M, STRIKE);
coverImmutableBean(test1);
FxOptionVolatilitiesNode test2 = FxOptionVolatilitiesNode.of(CurrencyPair.of(GBP, USD), DaysAdjustment.NONE, BusinessDayAdjustment.NONE, ValueType.RISK_REVERSAL, QuoteId.of(StandardId.of("OG", "foo")), Tenor.TENOR_6M, DeltaStrike.of(0.1));
coverBeanEquals(test1, test2);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @DataProvider(name = "currencyPair") public static Object[][] data_currency_pair()
public static object[][] data_currency_pair()
{
return(new object[][]
{
new object[] { FxSwapConventions.EUR_USD, CurrencyPair.of(EUR, USD) },
new object[] { FxSwapConventions.EUR_GBP, CurrencyPair.of(EUR, GBP) },
new object[] { FxSwapConventions.GBP_USD, CurrencyPair.of(GBP, USD) },
new object[] { FxSwapConventions.GBP_JPY, CurrencyPair.of(GBP, JPY) }
});
}
public virtual void test_of_rate_switchOrder()
{
FxSingle test = FxSingle.of(USD_M1600, FxRate.of(USD, GBP, 1d / 1.6d), DATE_2015_06_30);
assertEquals(test.BaseCurrencyAmount, GBP_P1000);
assertEquals(test.CounterCurrencyAmount, USD_M1600);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
//-------------------------------------------------------------------------
public virtual void test_of_rate_rightOrder()
{
ResolvedFxSingle test = ResolvedFxSingle.of(GBP_P1000, FxRate.of(GBP, USD, 1.6d), DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment, Payment.of(GBP_P1000, DATE_2015_06_30));
assertEquals(test.CounterCurrencyPayment, Payment.of(USD_M1600, DATE_2015_06_30));
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
public virtual void test_builder_switchOrder()
{
FxSingle test = FxSingle.meta().builder().set(FxSingle.meta().baseCurrencyPayment(), Payment.of(USD_M1600, DATE_2015_06_30)).set(FxSingle.meta().counterCurrencyPayment(), Payment.of(GBP_P1000, DATE_2015_06_30)).build();
assertEquals(test.BaseCurrencyAmount, GBP_P1000);
assertEquals(test.CounterCurrencyAmount, USD_M1600);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
public virtual void test_of_rate_bothZero()
{
FxSingle test = FxSingle.of(CurrencyAmount.zero(GBP), FxRate.of(USD, GBP, 1.6d), DATE_2015_06_30);
assertEquals(test.BaseCurrencyAmount, CurrencyAmount.zero(GBP));
assertEquals(test.CounterCurrencyAmount.Amount, CurrencyAmount.zero(USD).Amount, 1e-12);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, CurrencyAmount.of(USD, 0d));
}
public virtual void test_of_amounts_switchOrder()
{
ResolvedFxSingle test = ResolvedFxSingle.of(USD_M1600, GBP_P1000, DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment, PAYMENT_GBP_P1000);
assertEquals(test.CounterCurrencyPayment, PAYMENT_USD_M1600);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
public virtual void test_of_amounts_bothZero()
{
ResolvedFxSingle test = ResolvedFxSingle.of(CurrencyAmount.zero(GBP), CurrencyAmount.zero(USD), DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment, Payment.of(CurrencyAmount.zero(GBP), DATE_2015_06_30));
assertEquals(test.CounterCurrencyPayment, Payment.of(CurrencyAmount.zero(USD), DATE_2015_06_30));
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, CurrencyAmount.zero(USD));
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
double rate = 1.4d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(EUR, USD), rate);
FxForwardSensitivity test1 = (FxForwardSensitivity) @base.convertedTo(USD, matrix);
FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, USD, SENSITIVITY * rate);
assertEquals(test1, expected);
FxForwardSensitivity test2 = (FxForwardSensitivity) @base.convertedTo(EUR, matrix);
assertEquals(test2, @base);
}
public virtual void test_singleDiscountCurveParameterSensitivity()
{
ZeroRateSensitivity zeroPt = ZeroRateSensitivity.of(USD, 10d, 5d);
CreditCurveZeroRateSensitivity creditPt = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY_ABC, JPY, 2d, 3d);
FxForwardSensitivity fxPt = FxForwardSensitivity.of(CurrencyPair.of(JPY, USD), USD, LocalDate.of(2017, 2, 14), 15d);
CreditRatesProvider test = ImmutableCreditRatesProvider.builder().creditCurves(ImmutableMap.of(Pair.of(LEGAL_ENTITY_ABC, USD), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_USD), Pair.of(LEGAL_ENTITY_ABC, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_ABC, CRD_ABC_JPY), Pair.of(LEGAL_ENTITY_DEF, JPY), LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY_DEF, CRD_DEF))).discountCurves(ImmutableMap.of(USD, DSC_USD, JPY, DSC_JPY)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY_ABC, RR_ABC, LEGAL_ENTITY_DEF, RR_DEF)).valuationDate(VALUATION).build();
CurrencyParameterSensitivities computed = CurrencyParameterSensitivities.of(test.singleDiscountCurveParameterSensitivity(zeroPt.combinedWith(creditPt).combinedWith(fxPt).build(), USD));
CurrencyParameterSensitivities expected = DSC_USD.parameterSensitivity(zeroPt);
assertTrue(computed.equalWithTolerance(expected, 1.0e-14));
}
public virtual void getValues()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(Currency.EUR, Currency.USD, DoubleArray.of(1.07, 1.08, 1.09));
assertThat(rates.Pair).isEqualTo(CurrencyPair.of(Currency.EUR, Currency.USD));
assertThat(rates.ScenarioCount).isEqualTo(3);
assertThat(rates.get(0)).isEqualTo(FxRate.of(Currency.EUR, Currency.USD, 1.07));
assertThat(rates.get(1)).isEqualTo(FxRate.of(Currency.EUR, Currency.USD, 1.08));
assertThat(rates.get(2)).isEqualTo(FxRate.of(Currency.EUR, Currency.USD, 1.09));
assertThrows(typeof(System.IndexOutOfRangeException), () => rates.get(3));
}
public virtual void test_of_rate_withAdjustment()
{
FxSingle test = FxSingle.of(GBP_P1000, FxRate.of(GBP, USD, 1.6d), DATE_2015_06_30, BDA);
assertEquals(test.BaseCurrencyAmount, GBP_P1000);
assertEquals(test.CounterCurrencyAmount, USD_M1600);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.PaymentDateAdjustment, BDA);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
//-------------------------------------------------------------------------
public virtual void test_fxForwardRates()
{
ImmutableRatesProvider test = ImmutableRatesProvider.builder(VAL_DATE).fxRateProvider(FX_MATRIX).discountCurve(GBP, DISCOUNT_CURVE_GBP).discountCurve(USD, DISCOUNT_CURVE_USD).build();
DiscountFxForwardRates res = (DiscountFxForwardRates)test.fxForwardRates(CurrencyPair.of(GBP, USD));
assertEquals(res.BaseCurrencyDiscountFactors, ZeroRateDiscountFactors.of(GBP, VAL_DATE, DISCOUNT_CURVE_GBP));
assertEquals(res.CounterCurrencyDiscountFactors, ZeroRateDiscountFactors.of(USD, VAL_DATE, DISCOUNT_CURVE_USD));
assertEquals(res.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(res.FxRateProvider, FX_MATRIX);
assertEquals(res.ValuationDate, VAL_DATE);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
DiscountFxForwardRates test1 = DiscountFxForwardRates.of(CURRENCY_PAIR, FX_RATE, DFCURVE_GBP, DFCURVE_USD);
coverImmutableBean(test1);
DiscountFxForwardRates test2 = DiscountFxForwardRates.of(CURRENCY_PAIR, FX_RATE.inverse(), DFCURVE_GBP2, DFCURVE_USD2);
coverBeanEquals(test1, test2);
DiscountFxForwardRates test3 = DiscountFxForwardRates.of(CurrencyPair.of(USD, EUR), FxRate.of(EUR, USD, 1.2d), DFCURVE_USD, ZeroRateDiscountFactors.of(EUR, DATE_VAL, CURVE2));
coverBeanEquals(test1, test3);
}
public virtual void fxRate()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(CurrencyPair.of(Currency.EUR, Currency.USD), DoubleArray.of(1.07, 1.08, 1.09));
assertThat(rates.fxRate(Currency.EUR, Currency.USD, 0)).isEqualTo(1.07);
assertThat(rates.fxRate(Currency.EUR, Currency.USD, 1)).isEqualTo(1.08);
assertThat(rates.fxRate(Currency.EUR, Currency.USD, 2)).isEqualTo(1.09);
assertThat(rates.fxRate(Currency.USD, Currency.EUR, 0)).isEqualTo(1 / 1.07);
assertThat(rates.fxRate(Currency.USD, Currency.EUR, 1)).isEqualTo(1 / 1.08);
assertThat(rates.fxRate(Currency.USD, Currency.EUR, 2)).isEqualTo(1 / 1.09);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
BondFutureOptionSensitivity @base = BondFutureOptionSensitivity.of(NAME, OPTION_EXPIRY, FUTURE_EXPIRY, STRIKE_PRICE, FUTURE_PRICE, GBP, SENSITIVITY);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
BondFutureOptionSensitivity test1 = (BondFutureOptionSensitivity)@base.convertedTo(USD, matrix);
BondFutureOptionSensitivity expected = BondFutureOptionSensitivity.of(NAME, OPTION_EXPIRY, FUTURE_EXPIRY, STRIKE_PRICE, FUTURE_PRICE, USD, SENSITIVITY * rate);
assertEquals(test1, expected);
BondFutureOptionSensitivity test2 = (BondFutureOptionSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
FxIndexSensitivity @base = FxIndexSensitivity.of(GBP_USD_WM_OBS, GBP, SENSITIVITY_VALUE);
double rate = 1.35d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(EUR, USD), rate);
FxIndexSensitivity test1 = (FxIndexSensitivity)@base.convertedTo(EUR, matrix);
FxIndexSensitivity expected = FxIndexSensitivity.of(GBP_USD_WM_OBS, GBP, EUR, SENSITIVITY_VALUE / rate);
assertEquals(test1, expected);
FxIndexSensitivity test2 = (FxIndexSensitivity)@base.convertedTo(USD, matrix);
assertEquals(test2, @base);
}
public virtual void test_convertedTo()
{
IssuerCurveZeroRateSensitivity @base = IssuerCurveZeroRateSensitivity.of(CURRENCY, YEARFRAC, GROUP, VALUE);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IssuerCurveZeroRateSensitivity test1 = @base.convertedTo(USD, matrix);
assertEquals(test1, @base);
IssuerCurveZeroRateSensitivity test2 = @base.convertedTo(GBP, matrix);
IssuerCurveZeroRateSensitivity expected = IssuerCurveZeroRateSensitivity.of(CURRENCY, YEARFRAC, GBP, GROUP, VALUE / rate);
assertEquals(test2, expected);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
IborCapletFloorletSensitivity @base = IborCapletFloorletSensitivity.of(NAME, EXPIRY, STRIKE, FORWARD, GBP, SENSITIVITY);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IborCapletFloorletSensitivity test1 = @base.convertedTo(USD, matrix);
IborCapletFloorletSensitivity expected = IborCapletFloorletSensitivity.of(NAME, EXPIRY, STRIKE, FORWARD, USD, SENSITIVITY * rate);
assertEquals(test1, expected);
IborCapletFloorletSensitivity test2 = @base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
InflationRateSensitivity @base = InflationRateSensitivity.of(GB_HICP_OBS, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
InflationRateSensitivity test1 = (InflationRateSensitivity)@base.convertedTo(USD, matrix);
InflationRateSensitivity expected = InflationRateSensitivity.of(GB_HICP_OBS, USD, sensi * rate);
assertEquals(test1, expected);
InflationRateSensitivity test2 = (InflationRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
IborRateSensitivity @base = IborRateSensitivity.of(GBP_LIBOR_3M_OBSERVATION, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
IborRateSensitivity test1 = (IborRateSensitivity)@base.convertedTo(USD, matrix);
IborRateSensitivity expected = IborRateSensitivity.of(GBP_LIBOR_3M_OBSERVATION, USD, sensi * rate);
assertEquals(test1, expected);
IborRateSensitivity test2 = (IborRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
CreditCurveZeroRateSensitivity test1 = @base.convertedTo(USD, matrix);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, USD, rate * sensi);
assertEquals(test1, expected);
CreditCurveZeroRateSensitivity test2 = @base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
double sensi = 32d;
ZeroRateSensitivity @base = ZeroRateSensitivity.of(GBP, YEARFRAC, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
ZeroRateSensitivity test1 = (ZeroRateSensitivity)@base.convertedTo(USD, matrix);
ZeroRateSensitivity expected = ZeroRateSensitivity.of(GBP, YEARFRAC, USD, rate * sensi);
assertEquals(test1, expected);
ZeroRateSensitivity test2 = (ZeroRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
