//-------------------------------------------------------------------------
public PointSensitivityBuilder periodRatePointSensitivity(OvernightIndexObservation startDateObservation, LocalDate endDate)
{
LocalDate startDate = startDateObservation.EffectiveDate;
ArgChecker.inOrderNotEqual(startDate, endDate, "startDate", "endDate");
return(OvernightRateSensitivity.ofPeriod(startDateObservation, endDate, 1d));
}
//-------------------------------------------------------------------------
public virtual void test_build()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
PointSensitivities test = @base.build();
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
//-------------------------------------------------------------------------
// proper end-to-end tests are elsewhere
public virtual void test_parameterSensitivity()
{
DiscountOvernightIndexRates test = DiscountOvernightIndexRates.of(GBP_SONIA, DFCURVE, SERIES);
OvernightRateSensitivity point = OvernightRateSensitivity.ofPeriod(GBP_SONIA_AFTER, DATE_AFTER_END, GBP, 1d);
assertEquals(test.parameterSensitivity(point).size(), 1);
}
public virtual void test_rateIgnoringFixingsPointSensitivity_onValuation()
{
DiscountOvernightIndexRates test = DiscountOvernightIndexRates.of(GBP_SONIA, DFCURVE, SERIES);
OvernightRateSensitivity expected = OvernightRateSensitivity.of(GBP_SONIA_VAL, 1d);
assertEquals(test.rateIgnoringFixingsPointSensitivity(GBP_SONIA_VAL), expected);
}
public virtual void test_ratePointSensitivity_onPublication_noFixing()
{
DiscountOvernightIndexRates test = DiscountOvernightIndexRates.of(GBP_SONIA, DFCURVE, SERIES_EMPTY);
OvernightRateSensitivity expected = OvernightRateSensitivity.of(GBP_SONIA_VAL, 1d);
assertEquals(test.ratePointSensitivity(GBP_SONIA_VAL), expected);
}
public virtual void test_ratePointSensitivity_afterPublication()
{
DiscountOvernightIndexRates test = DiscountOvernightIndexRates.of(GBP_SONIA, DFCURVE, SERIES);
OvernightRateSensitivity expected = OvernightRateSensitivity.of(GBP_SONIA_AFTER, 1d);
assertEquals(test.ratePointSensitivity(GBP_SONIA_AFTER), expected);
}
//-------------------------------------------------------------------------
public virtual void test_periodRatePointSensitivity()
{
DiscountOvernightIndexRates test = DiscountOvernightIndexRates.of(GBP_SONIA, DFCURVE, SERIES);
OvernightRateSensitivity expected = OvernightRateSensitivity.ofPeriod(GBP_SONIA_AFTER, DATE_AFTER_END, GBP, 1d);
assertEquals(test.periodRatePointSensitivity(GBP_SONIA_AFTER, DATE_AFTER_END), expected);
}
//-------------------------------------------------------------------------
public virtual void test_cloned()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
OvernightRateSensitivity test = @base.cloned();
assertSame(test, @base);
}
//-------------------------------------------------------------------------
public virtual void test_mapSensitivity()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
OvernightRateSensitivity expected = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 1 / 32d);
OvernightRateSensitivity test = @base.mapSensitivity(s => 1 / s);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_multipliedBy()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
OvernightRateSensitivity expected = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d * 3.5d);
OvernightRateSensitivity test = @base.multipliedBy(3.5d);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_withSensitivity()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
OvernightRateSensitivity expected = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 20d);
OvernightRateSensitivity test = @base.withSensitivity(20d);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
OvernightRateSensitivity test = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
coverImmutableBean(test);
OvernightRateSensitivity test2 = OvernightRateSensitivity.of(USD_FED_FUND_OBSERVATION2, 16d);
coverBeanEquals(test, test2);
}
public int compareKey(PointSensitivity other)
{
if (other is OvernightRateSensitivity)
{
OvernightRateSensitivity otherOn = (OvernightRateSensitivity)other;
return(ComparisonChain.start().compare(Index.ToString(), otherOn.Index.ToString()).compare(currency, otherOn.currency).compare(observation.FixingDate, otherOn.observation.FixingDate).compare(endDate, otherOn.endDate).result());
}
return(this.GetType().Name.CompareTo(other.GetType().Name));
}
//-------------------------------------------------------------------------
public virtual void test_buildInto()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
MutablePointSensitivities combo = new MutablePointSensitivities();
MutablePointSensitivities test = @base.buildInto(combo);
assertSame(test, combo);
assertEquals(test.Sensitivities, ImmutableList.of(@base));
}
public virtual void test_ofPeriod()
{
OvernightRateSensitivity test = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, date(2015, 10, 27), GBP, 32d);
assertEquals(test.Index, GBP_SONIA);
assertEquals(test.Currency, GBP);
assertEquals(test.EndDate, date(2015, 10, 27));
assertEquals(test.Sensitivity, 32d);
assertEquals(test.Index, GBP_SONIA);
}
public virtual void test_combinedWith_mutable()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(@base);
PointSensitivityBuilder test = @base.combinedWith(new MutablePointSensitivities());
assertEquals(test, expected);
}
public virtual void test_of_currency()
{
OvernightRateSensitivity test = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, USD, 32d);
assertEquals(test.Index, GBP_SONIA);
assertEquals(test.Currency, USD);
assertEquals(test.EndDate, date(2015, 8, 28));
assertEquals(test.Sensitivity, 32d);
assertEquals(test.Index, GBP_SONIA);
}
//-------------------------------------------------------------------------
public virtual void test_combinedWith()
{
OvernightRateSensitivity base1 = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
OvernightRateSensitivity base2 = OvernightRateSensitivity.of(OvernightIndexObservation.of(GBP_SONIA, date(2015, 10, 27), REF_DATA), 22d);
MutablePointSensitivities expected = new MutablePointSensitivities();
expected.add(base1).add(base2);
PointSensitivityBuilder test = base1.combinedWith(base2);
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public PointSensitivityBuilder ratePointSensitivity(OvernightIndexObservation observation)
{
LocalDate valuationDate = ValuationDate;
LocalDate fixingDate = observation.FixingDate;
LocalDate publicationDate = observation.PublicationDate;
if (publicationDate.isBefore(valuationDate) || (publicationDate.Equals(valuationDate) && fixings.get(fixingDate).HasValue))
{
return(PointSensitivityBuilder.none());
}
return(OvernightRateSensitivity.of(observation, 1d));
}
//-------------------------------------------------------------------------
public virtual void test_withCurrency()
{
OvernightRateSensitivity @base = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
assertSame(@base.withCurrency(GBP), @base);
LocalDate mat = GBP_SONIA_OBSERVATION.MaturityDate;
OvernightRateSensitivity expected = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, mat, USD, 32d);
OvernightRateSensitivity test = @base.withCurrency(USD);
assertEquals(test, expected);
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
OvernightRateSensitivity other = (OvernightRateSensitivity)obj;
return(JodaBeanUtils.equal(observation, other.observation) && JodaBeanUtils.equal(endDate, other.endDate) && JodaBeanUtils.equal(currency, other.currency) && JodaBeanUtils.equal(sensitivity, other.sensitivity));
}
return(false);
}
public virtual void test_periodRatePointSensitivity_onholidaybeforepublication()
{
LocalDate lastFixingDate = LocalDate.of(2017, 6, 30);
LocalDate gbdBeforeValDate = LocalDate.of(2017, 7, 3);
LocalDate gbdAfterValDate = LocalDate.of(2017, 7, 5);
double fixingValue = 0.0010;
InterpolatedNodalCurve curve = InterpolatedNodalCurve.of(METADATA, DoubleArray.of(-1.0d, 10.0d), DoubleArray.of(0.01, 0.02), INTERPOLATOR);
ZeroRateDiscountFactors df = ZeroRateDiscountFactors.of(USD, LocalDate.of(2017, 7, 4), curve);
LocalDateDoubleTimeSeries series = LocalDateDoubleTimeSeries.builder().put(lastFixingDate, fixingValue).build();
DiscountOvernightIndexRates test = DiscountOvernightIndexRates.of(USD_FED_FUND, df, series);
OvernightIndexObservation obs = OvernightIndexObservation.of(USD_FED_FUND, gbdBeforeValDate, REF_DATA);
OvernightRateSensitivity expected = OvernightRateSensitivity.ofPeriod(obs, gbdAfterValDate, USD, 1d);
assertEquals(test.periodRatePointSensitivity(obs, gbdAfterValDate), expected);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo()
{
LocalDate fixingDate = DATE;
LocalDate endDate = date(2015, 10, 27);
double sensi = 32d;
OvernightRateSensitivity @base = OvernightRateSensitivity.ofPeriod(OvernightIndexObservation.of(GBP_SONIA, fixingDate, REF_DATA), endDate, GBP, sensi);
double rate = 1.5d;
FxMatrix matrix = FxMatrix.of(CurrencyPair.of(GBP, USD), rate);
OvernightRateSensitivity test1 = (OvernightRateSensitivity)@base.convertedTo(USD, matrix);
OvernightRateSensitivity expected = OvernightRateSensitivity.ofPeriod(OvernightIndexObservation.of(GBP_SONIA, fixingDate, REF_DATA), endDate, USD, rate * sensi);
assertEquals(test1, expected);
OvernightRateSensitivity test2 = (OvernightRateSensitivity)@base.convertedTo(GBP, matrix);
assertEquals(test2, @base);
}
//-------------------------------------------------------------------------
public CurrencyParameterSensitivities parameterSensitivity(OvernightRateSensitivity pointSensitivity)
{
OvernightIndex index = pointSensitivity.Index;
LocalDate startDate = pointSensitivity.Observation.EffectiveDate;
LocalDate endDate = pointSensitivity.EndDate;
double accrualFactor = index.DayCount.yearFraction(startDate, endDate);
double forwardBar = pointSensitivity.Sensitivity;
double dfForwardStart = discountFactors.discountFactor(startDate);
double dfForwardEnd = discountFactors.discountFactor(endDate);
double dfStartBar = forwardBar / (accrualFactor * dfForwardEnd);
double dfEndBar = -forwardBar * dfForwardStart / (accrualFactor * dfForwardEnd * dfForwardEnd);
ZeroRateSensitivity zrsStart = discountFactors.zeroRatePointSensitivity(startDate, pointSensitivity.Currency);
ZeroRateSensitivity zrsEnd = discountFactors.zeroRatePointSensitivity(endDate, pointSensitivity.Currency);
CurrencyParameterSensitivities psStart = discountFactors.parameterSensitivity(zrsStart).multipliedBy(dfStartBar);
CurrencyParameterSensitivities psEnd = discountFactors.parameterSensitivity(zrsEnd).multipliedBy(dfEndBar);
return(psStart.combinedWith(psEnd));
}
//-------------------------------------------------------------------------
public virtual void test_compareKey()
{
OvernightRateSensitivity a1 = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, date(2015, 10, 27), GBP, 32d);
OvernightRateSensitivity a2 = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, date(2015, 10, 27), GBP, 32d);
OvernightRateSensitivity b = OvernightRateSensitivity.ofPeriod(USD_FED_FUND_OBSERVATION2, date(2015, 10, 27), GBP, 32d);
OvernightRateSensitivity c = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, date(2015, 10, 27), USD, 32d);
OvernightRateSensitivity d = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION2, date(2015, 10, 27), GBP, 32d);
OvernightRateSensitivity e = OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, date(2015, 11, 27), GBP, 32d);
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(e) < 0, true);
assertEquals(d.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(d) < 0, true);
assertEquals(e.compareKey(a1) > 0, true);
assertEquals(a1.compareKey(other) < 0, true);
assertEquals(other.compareKey(a1) > 0, true);
}
public PointSensitivityBuilder rateIgnoringFixingsPointSensitivity(OvernightIndexObservation observation)
{
return(OvernightRateSensitivity.of(observation, 1d));
}
public virtual void test_badDateOrder()
{
assertThrowsIllegalArg(() => OvernightRateSensitivity.ofPeriod(GBP_SONIA_OBSERVATION, DATE, GBP, 32d));
}
public virtual void test_serialization()
{
OvernightRateSensitivity test = OvernightRateSensitivity.of(GBP_SONIA_OBSERVATION, 32d);
assertSerialization(test);
}
