//-------------------------------------------------------------------------
public virtual void test_ratePointSensitivity()
{
DiscountFxForwardRates test = DiscountFxForwardRates.of(CURRENCY_PAIR, FX_RATE, DFCURVE_GBP, DFCURVE_USD);
assertEquals(test.ratePointSensitivity(GBP, DATE_REF), FxForwardSensitivity.of(CURRENCY_PAIR, GBP, DATE_REF, 1d));
assertEquals(test.ratePointSensitivity(USD, DATE_REF), FxForwardSensitivity.of(CURRENCY_PAIR, USD, DATE_REF, 1d));
}
//-------------------------------------------------------------------------
public virtual void test_multipliedBy()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity test = @base.multipliedBy(2.4d);
FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY * 2.4d);
assertEquals(test, expected);
}
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);
}
//-------------------------------------------------------------------------
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_mapSensitivity()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity test = @base.mapSensitivity(s => 1d / s);
FxForwardSensitivity expected = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, 1d / SENSITIVITY);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
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 test_buildInto()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
MutablePointSensitivities combo = new MutablePointSensitivities();
MutablePointSensitivities test = @base.buildInto(combo);
assertSame(test, combo);
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
public virtual void test_combinedWith_mutable()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(@base);
PointSensitivityBuilder test = @base.combinedWith(new MutablePointSensitivities());
assertEquals(test, expected);
}
public int compareKey(PointSensitivity other)
{
if (other is FxForwardSensitivity)
{
FxForwardSensitivity otherFx = (FxForwardSensitivity)other;
return(ComparisonChain.start().compare(currencyPair.ToString(), otherFx.currencyPair.ToString()).compare(currency, otherFx.currency).compare(referenceCurrency, otherFx.referenceCurrency).compare(referenceDate, otherFx.referenceDate).result());
}
return(this.GetType().Name.CompareTo(other.GetType().Name));
}
//-------------------------------------------------------------------------
public virtual void test_combinedWith()
{
FxForwardSensitivity base1 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity base2 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, 1.56d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(base1).add(base2);
PointSensitivityBuilder test = base1.combinedWith(base2);
assertEquals(test, expected);
}
public virtual void test_of_withoutCurrency()
{
FxForwardSensitivity test = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
assertEquals(test.Currency, EUR);
assertEquals(test.CurrencyPair, CURRENCY_PAIR);
assertEquals(test.ReferenceCounterCurrency, EUR);
assertEquals(test.ReferenceCurrency, GBP);
assertEquals(test.ReferenceDate, REFERENCE_DATE);
assertEquals(test.Sensitivity, SENSITIVITY);
}
//-------------------------------------------------------------------------
//proper end-to-end tests are elsewhere
public virtual void test_parameterSensitivity()
{
DiscountFxForwardRates test = DiscountFxForwardRates.of(CURRENCY_PAIR, FX_RATE, DFCURVE_GBP, DFCURVE_USD);
FxForwardSensitivity point = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, DATE_VAL, 1d);
assertEquals(test.parameterSensitivity(point).size(), 2);
FxForwardSensitivity point2 = FxForwardSensitivity.of(CURRENCY_PAIR, USD, DATE_VAL, 1d);
assertEquals(test.parameterSensitivity(point2).size(), 2);
}
public virtual void test_withCurrency_other()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity test = @base.withCurrency(USD);
assertEquals(test.Currency, USD);
assertEquals(test.CurrencyPair, CURRENCY_PAIR);
assertEquals(test.ReferenceCounterCurrency, EUR);
assertEquals(test.ReferenceCurrency, GBP);
assertEquals(test.ReferenceDate, REFERENCE_DATE);
assertEquals(test.Sensitivity, SENSITIVITY);
}
//-------------------------------------------------------------------------
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 override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
FxForwardSensitivity other = (FxForwardSensitivity)obj;
return(JodaBeanUtils.equal(currencyPair, other.currencyPair) && JodaBeanUtils.equal(referenceCurrency, other.referenceCurrency) && JodaBeanUtils.equal(referenceDate, other.referenceDate) && JodaBeanUtils.equal(currency, other.currency) && JodaBeanUtils.equal(sensitivity, other.sensitivity));
}
return(false);
}
//-------------------------------------------------------------------------
public virtual void test_compareKey()
{
FxForwardSensitivity a1 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, EUR, SENSITIVITY);
FxForwardSensitivity a2 = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, EUR, SENSITIVITY);
FxForwardSensitivity b = FxForwardSensitivity.of(CurrencyPair.of(GBP, USD), GBP, REFERENCE_DATE, EUR, SENSITIVITY);
FxForwardSensitivity c = FxForwardSensitivity.of(CURRENCY_PAIR, EUR, REFERENCE_DATE, GBP, SENSITIVITY);
FxForwardSensitivity d = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, JPY, SENSITIVITY);
FxForwardSensitivity e = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, date(2015, 9, 27), SENSITIVITY);
ZeroRateSensitivity other = ZeroRateSensitivity.of(GBP, 2d, SENSITIVITY);
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(other) < 0, true);
assertEquals(other.compareKey(a1) > 0, true);
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(FxForwardSensitivity pointSensitivity)
{
// use the specified base currency to determine the desired currency pair
// then derive sensitivity from discount factors based off desired currency pair, not that of the index
CurrencyPair currencyPair = pointSensitivity.CurrencyPair;
Currency refBaseCurrency = pointSensitivity.ReferenceCurrency;
Currency refCounterCurrency = pointSensitivity.ReferenceCounterCurrency;
Currency sensitivityCurrency = pointSensitivity.Currency;
LocalDate referenceDate = pointSensitivity.ReferenceDate;
bool inverse = refBaseCurrency.Equals(currencyPair.Counter);
DiscountFactors discountFactorsRefBase = (inverse ? counterCurrencyDiscountFactors : baseCurrencyDiscountFactors);
DiscountFactors discountFactorsRefCounter = (inverse ? baseCurrencyDiscountFactors : counterCurrencyDiscountFactors);
double dfCcyBaseAtMaturity = discountFactorsRefBase.discountFactor(referenceDate);
double dfCcyCounterAtMaturityInv = 1d / discountFactorsRefCounter.discountFactor(referenceDate);
double fxRate = fxRateProvider.fxRate(refBaseCurrency, refCounterCurrency);
ZeroRateSensitivity dfCcyBaseAtMaturitySensitivity = discountFactorsRefBase.zeroRatePointSensitivity(referenceDate, sensitivityCurrency).multipliedBy(fxRate * dfCcyCounterAtMaturityInv * pointSensitivity.Sensitivity);
ZeroRateSensitivity dfCcyCounterAtMaturitySensitivity = discountFactorsRefCounter.zeroRatePointSensitivity(referenceDate, sensitivityCurrency).multipliedBy(-fxRate * dfCcyBaseAtMaturity * dfCcyCounterAtMaturityInv * dfCcyCounterAtMaturityInv * pointSensitivity.Sensitivity);
return(discountFactorsRefBase.parameterSensitivity(dfCcyBaseAtMaturitySensitivity).combinedWith(discountFactorsRefCounter.parameterSensitivity(dfCcyCounterAtMaturitySensitivity)));
}
public MultiCurrencyAmount currencyExposure(FxForwardSensitivity pointSensitivity)
{
ArgChecker.isTrue(pointSensitivity.Currency.Equals(pointSensitivity.ReferenceCurrency), "Currency exposure defined only when sensitivity currency equal reference currency");
Currency ccyRef = pointSensitivity.ReferenceCurrency;
CurrencyPair pair = pointSensitivity.CurrencyPair;
double s = pointSensitivity.Sensitivity;
LocalDate d = pointSensitivity.ReferenceDate;
double f = fxRateProvider.fxRate(pair.Base, pair.Counter);
double pA = baseCurrencyDiscountFactors.discountFactor(d);
double pB = counterCurrencyDiscountFactors.discountFactor(d);
if (ccyRef.Equals(pair.Base))
{
CurrencyAmount amountCounter = CurrencyAmount.of(pair.Base, s * f * pA / pB);
CurrencyAmount amountBase = CurrencyAmount.of(pair.Counter, -s * f * f * pA / pB);
return(MultiCurrencyAmount.of(amountBase, amountCounter));
}
else
{
CurrencyAmount amountBase = CurrencyAmount.of(pair.Base, -s * pB / (pA * f * f));
CurrencyAmount amountCounter = CurrencyAmount.of(pair.Counter, s * pB / (pA * f));
return(MultiCurrencyAmount.of(amountBase, amountCounter));
}
}
//-------------------------------------------------------------------------
public virtual void test_cloned()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity test = @base.cloned();
assertSame(test, @base);
}
//-------------------------------------------------------------------------
public virtual void test_build()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
PointSensitivities test = @base.build();
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
//-------------------------------------------------------------------------
public PointSensitivityBuilder ratePointSensitivity(Currency baseCurrency, LocalDate referenceDate)
{
ArgChecker.isTrue(currencyPair.contains(baseCurrency), "Currency {} invalid for CurrencyPair {}", baseCurrency, currencyPair);
return(FxForwardSensitivity.of(currencyPair, baseCurrency, referenceDate, 1d));
}
//-------------------------------------------------------------------------
public virtual void test_withCurrency_same()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity test = @base.withCurrency(EUR);
assertEquals(test, @base);
}
public virtual void test_serialization()
{
FxForwardSensitivity test = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
assertSerialization(test);
}
public virtual void test_of_wrongRefCurrency()
{
assertThrowsIllegalArg(() => FxForwardSensitivity.of(CURRENCY_PAIR, USD, REFERENCE_DATE, SENSITIVITY));
assertThrowsIllegalArg(() => FxForwardSensitivity.of(CURRENCY_PAIR, USD, REFERENCE_DATE, USD, SENSITIVITY));
}
//-------------------------------------------------------------------------
public virtual void test_normalize()
{
FxForwardSensitivity @base = FxForwardSensitivity.of(CURRENCY_PAIR, GBP, REFERENCE_DATE, SENSITIVITY);
FxForwardSensitivity test = @base.normalize();
assertEquals(test, @base);
}
//-------------------------------------------------------------------------
/// <summary>
/// Converts this sensitivity to an {@code FxForwardSensitivity}.
/// <para>
/// The time series, fixing date and FX index are lost by this conversion.
/// Instead, maturity date and currency pair are contained in <seealso cref="FxForwardSensitivity"/>.
///
/// </para>
/// </summary>
/// <returns> the FX forward sensitivity </returns>
public FxForwardSensitivity toFxForwardSensitivity()
{
return(FxForwardSensitivity.of(observation.CurrencyPair, referenceCurrency, observation.MaturityDate, currency, sensitivity));
}
