public virtual void test_zeroRatePointSensitivity_sensitivityCurrency()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, DFS.zeroRatePointSensitivity(DATE_AFTER, GBP));
assertEquals(test.zeroRatePointSensitivity(DATE_AFTER, GBP), expected);
}
//-------------------------------------------------------------------------
public virtual void test_build()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
PointSensitivities test = @base.build();
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
//-------------------------------------------------------------------------
public virtual void test_cloned()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity test = @base.cloned();
assertSame(test, @base);
}
//-------------------------------------------------------------------------
public virtual void test_withCurrency()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, VALUE);
assertSame(@base.withCurrency(USD), @base);
assertEquals(@base.withCurrency(GBP), CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, GBP, VALUE));
}
//-------------------------------------------------------------------------
// proper end-to-end FD tests are in pricer test
public virtual void test_parameterSensitivity()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity point = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, ZeroRateSensitivity.of(USD, 1d, 1d));
assertEquals(test.parameterSensitivity(point).size(), 1);
}
//-------------------------------------------------------------------------
public virtual void test_unitParameterSensitivity()
{
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity sens = test.zeroRatePointSensitivity(DATE_AFTER);
CurrencyParameterSensitivities expected = DFS.parameterSensitivity(DFS.zeroRatePointSensitivity(DATE_AFTER));
assertEquals(test.parameterSensitivity(sens), expected);
}
public virtual void test_zeroRatePointSensitivity_sensitivityCurrency_yearFraction()
{
double yearFraction = DFS.relativeYearFraction(DATE_AFTER);
LegalEntitySurvivalProbabilities test = LegalEntitySurvivalProbabilities.of(LEGAL_ENTITY, DFS);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, DFS.zeroRatePointSensitivity(yearFraction, GBP));
assertEquals(test.zeroRatePointSensitivity(yearFraction, GBP), expected);
}
//-------------------------------------------------------------------------
public virtual void test_withSensitivity()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, VALUE);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, 20d);
CreditCurveZeroRateSensitivity test = @base.withSensitivity(20d);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_mapSensitivity()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 1 / 32d);
CreditCurveZeroRateSensitivity test = @base.mapSensitivity(s => 1 / s);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_multipliedBy()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity expected = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d * 3.5d);
CreditCurveZeroRateSensitivity test = @base.multipliedBy(3.5d);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_buildInto()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
MutablePointSensitivities combo = new MutablePointSensitivities();
MutablePointSensitivities test = @base.buildInto(combo);
assertSame(test, combo);
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
CreditCurveZeroRateSensitivity test = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
coverImmutableBean(test);
CreditCurveZeroRateSensitivity test2 = CreditCurveZeroRateSensitivity.of(StandardId.of("OG", "AAA"), USD, YEAR_FRACTION, 16d);
coverBeanEquals(test, test2);
}
public int compareKey(PointSensitivity other)
{
if (other is CreditCurveZeroRateSensitivity)
{
CreditCurveZeroRateSensitivity otherZero = (CreditCurveZeroRateSensitivity)other;
return(ComparisonChain.start().compare(zeroRateSensitivity.YearFraction, otherZero.zeroRateSensitivity.YearFraction).compare(zeroRateSensitivity.Currency, otherZero.zeroRateSensitivity.Currency).compare(zeroRateSensitivity.CurveCurrency, otherZero.zeroRateSensitivity.CurveCurrency).compare(legalEntityId, otherZero.legalEntityId).result());
}
return(this.GetType().Name.CompareTo(other.GetType().Name));
}
public virtual void test_combinedWith_mutable()
{
CreditCurveZeroRateSensitivity @base = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(@base);
PointSensitivityBuilder test = @base.combinedWith(new MutablePointSensitivities());
assertEquals(test, expected);
}
public virtual void test_of()
{
CreditCurveZeroRateSensitivity test = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, VALUE);
assertEquals(test.Currency, USD);
assertEquals(test.CurveCurrency, USD);
assertEquals(test.LegalEntityId, LEGAL_ENTITY);
assertEquals(test.Sensitivity, VALUE);
assertEquals(test.YearFraction, YEAR_FRACTION);
}
//-------------------------------------------------------------------------
public virtual void test_combinedWith()
{
CreditCurveZeroRateSensitivity base1 = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity base2 = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 22d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(base1).add(base2);
PointSensitivityBuilder test = base1.combinedWith(base2);
assertEquals(test, expected);
}
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 test_of_ZeroRateSensitivity()
{
ZeroRateSensitivity zeroPoint = ZeroRateSensitivity.of(USD, YEAR_FRACTION, GBP, VALUE);
CreditCurveZeroRateSensitivity test = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, zeroPoint);
assertEquals(test.Currency, GBP);
assertEquals(test.CurveCurrency, USD);
assertEquals(test.LegalEntityId, LEGAL_ENTITY);
assertEquals(test.Sensitivity, VALUE);
assertEquals(test.YearFraction, YEAR_FRACTION);
assertEquals(test.toZeroRateSensitivity(), zeroPoint);
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
CreditCurveZeroRateSensitivity other = (CreditCurveZeroRateSensitivity)obj;
return(JodaBeanUtils.equal(legalEntityId, other.legalEntityId) && JodaBeanUtils.equal(zeroRateSensitivity, other.zeroRateSensitivity));
}
return(false);
}
//-------------------------------------------------------------------------
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_compareKey()
{
CreditCurveZeroRateSensitivity a1 = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity a2 = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity b = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, 10d, 32d);
CreditCurveZeroRateSensitivity c = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, 32d);
CreditCurveZeroRateSensitivity d = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, USD, YEAR_FRACTION, GBP, 32d);
IborRateSensitivity other = IborRateSensitivity.of(IborIndexObservation.of(GBP_LIBOR_3M, date(2014, 6, 30), REF_DATA), 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(a1.compareKey(d) < 0, true);
assertEquals(c.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(other) < 0, true);
assertEquals(other.compareKey(a1) > 0, true);
}
public CurrencyParameterSensitivity singleCreditCurveParameterSensitivity(PointSensitivities pointSensitivities, StandardId legalEntityId, Currency currency)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is CreditCurveZeroRateSensitivity)
{
CreditCurveZeroRateSensitivity pt = (CreditCurveZeroRateSensitivity)point;
if (pt.LegalEntityId.Equals(legalEntityId) && pt.Currency.Equals(currency))
{
LegalEntitySurvivalProbabilities factors = survivalProbabilities(pt.LegalEntityId, pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
}
}
ArgChecker.isTrue(sens.size() == 1, "sensitivity must be unique");
return(sens.Sensitivities.get(0));
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(PointSensitivities pointSensitivities)
{
CurrencyParameterSensitivities sens = CurrencyParameterSensitivities.empty();
foreach (PointSensitivity point in pointSensitivities.Sensitivities)
{
if (point is CreditCurveZeroRateSensitivity)
{
CreditCurveZeroRateSensitivity pt = (CreditCurveZeroRateSensitivity)point;
LegalEntitySurvivalProbabilities factors = survivalProbabilities(pt.LegalEntityId, pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
else if (point is ZeroRateSensitivity)
{
ZeroRateSensitivity pt = (ZeroRateSensitivity)point;
CreditDiscountFactors factors = discountFactors(pt.CurveCurrency);
sens = sens.combinedWith(factors.parameterSensitivity(pt));
}
}
return(sens);
}
/// <summary>
/// Calculates the zero rate point sensitivity at the specified date specifying the currency of the sensitivity.
/// <para>
/// This returns a sensitivity instance referring to the zero hazard rate sensitivity of the
/// points that were queried in the market data.
/// The sensitivity typically has the value {@code (-survivalProbability * yearFraction)}.
/// The sensitivity refers to the result of <seealso cref="#survivalProbability(LocalDate)"/>.
/// </para>
/// <para>
/// This method allows the currency of the sensitivity to differ from the currency of the market data.
///
/// </para>
/// </summary>
/// <param name="date"> the date </param>
/// <param name="sensitivityCurrency"> the currency of the sensitivity </param>
/// <returns> the point sensitivity of the zero rate </returns>
/// <exception cref="RuntimeException"> if the result cannot be calculated </exception>
public CreditCurveZeroRateSensitivity zeroRatePointSensitivity(LocalDate date, Currency sensitivityCurrency)
{
ZeroRateSensitivity zeroRateSensitivity = survivalProbabilities.zeroRatePointSensitivity(date, sensitivityCurrency);
return(CreditCurveZeroRateSensitivity.of(legalEntityId, zeroRateSensitivity));
}
/// <summary>
/// Calculates the parameter sensitivity from the point sensitivity.
/// <para>
/// This is used to convert a single point sensitivity to parameter sensitivity.
/// The calculation typically involves multiplying the point and unit sensitivities.
///
/// </para>
/// </summary>
/// <param name="pointSensitivity"> the point sensitivity to convert </param>
/// <returns> the parameter sensitivity </returns>
/// <exception cref="RuntimeException"> if the result cannot be calculated </exception>
public CurrencyParameterSensitivities parameterSensitivity(CreditCurveZeroRateSensitivity pointSensitivity)
{
return(survivalProbabilities.parameterSensitivity(pointSensitivity.toZeroRateSensitivity()));
}
public virtual void test_serialization()
{
CreditCurveZeroRateSensitivity test = CreditCurveZeroRateSensitivity.of(LEGAL_ENTITY, GBP, YEAR_FRACTION, 32d);
assertSerialization(test);
}
/// <summary>
/// Calculates the zero rate point sensitivity at the specified year fraction specifying the currency of the sensitivity.
/// <para>
/// This returns a sensitivity instance referring to the zero hazard rate sensitivity of the
/// points that were queried in the market data.
/// The sensitivity typically has the value {@code (-survivalProbability * yearFraction)}.
/// The sensitivity refers to the result of <seealso cref="#survivalProbability(LocalDate)"/>.
/// </para>
/// <para>
/// This method allows the currency of the sensitivity to differ from the currency of the market data.
///
/// </para>
/// </summary>
/// <param name="yearFraction"> the year fraction </param>
/// <param name="sensitivityCurrency"> the currency of the sensitivity </param>
/// <returns> the point sensitivity of the zero rate </returns>
/// <exception cref="RuntimeException"> if the result cannot be calculated </exception>
public CreditCurveZeroRateSensitivity zeroRatePointSensitivity(double yearFraction, Currency sensitivityCurrency)
{
ZeroRateSensitivity zeroRateSensitivity = survivalProbabilities.zeroRatePointSensitivity(yearFraction, sensitivityCurrency);
return(CreditCurveZeroRateSensitivity.of(legalEntityId, zeroRateSensitivity));
}
