//-------------------------------------------------------------------------
// build conventions
private static OvernightIborSwapConvention makeConvention(string name, OvernightIndex onIndex, IborIndex iborIndex, DayCount dayCount, Frequency frequency, int paymentLag, int cutOffDays, OvernightAccrualMethod accrual)
{
HolidayCalendarId calendarOn = onIndex.FixingCalendar;
DaysAdjustment paymentDateOffset = DaysAdjustment.ofBusinessDays(paymentLag, calendarOn);
return(ImmutableOvernightIborSwapConvention.of(name, OvernightRateSwapLegConvention.builder().index(onIndex).accrualMethod(accrual).accrualFrequency(frequency).paymentFrequency(frequency).paymentDateOffset(paymentDateOffset).stubConvention(StubConvention.SMART_INITIAL).rateCutOffDays(cutOffDays).build(), IborRateSwapLegConvention.of(iborIndex)));
}
public virtual void test_inflation_fixed()
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, GBLO);
PeriodicSchedule accrualSchedule = PeriodicSchedule.builder().startDate(DATE_14_06_09).endDate(DATE_19_06_09).frequency(P12M).businessDayAdjustment(bda).build();
PaymentSchedule paymentSchedule = PaymentSchedule.builder().paymentFrequency(Frequency.ofYears(5)).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).compoundingMethod(STRAIGHT).build();
FixedRateCalculation rateCalc = FixedRateCalculation.builder().rate(ValueSchedule.of(0.05)).dayCount(ONE_ONE).build();
NotionalSchedule notionalSchedule = NotionalSchedule.of(GBP, 1000d);
RateCalculationSwapLeg test = RateCalculationSwapLeg.builder().payReceive(RECEIVE).accrualSchedule(accrualSchedule).paymentSchedule(paymentSchedule).notionalSchedule(notionalSchedule).calculation(rateCalc).build();
assertEquals(test.StartDate, AdjustableDate.of(DATE_14_06_09, bda));
assertEquals(test.EndDate, AdjustableDate.of(DATE_19_06_09, bda));
assertEquals(test.Currency, GBP);
assertEquals(test.PayReceive, RECEIVE);
assertEquals(test.AccrualSchedule, accrualSchedule);
assertEquals(test.PaymentSchedule, paymentSchedule);
assertEquals(test.NotionalSchedule, notionalSchedule);
assertEquals(test.Calculation, rateCalc);
RateAccrualPeriod rap0 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09, REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(1), REF_DATA)).unadjustedStartDate(DATE_14_06_09).unadjustedEndDate(DATE_14_06_09.plusYears(1)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap1 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(1), REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(2), REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(1)).unadjustedEndDate(DATE_14_06_09.plusYears(2)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap2 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(2), REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(3), REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(2)).unadjustedEndDate(DATE_14_06_09.plusYears(3)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap3 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(3), REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(4), REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(3)).unadjustedEndDate(DATE_14_06_09.plusYears(4)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap4 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(4), REF_DATA)).endDate(bda.adjust(DATE_19_06_09, REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(4)).unadjustedEndDate(DATE_19_06_09).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RatePaymentPeriod rpp = RatePaymentPeriod.builder().paymentDate(DaysAdjustment.ofBusinessDays(2, GBLO).adjust(bda.adjust(DATE_19_06_09, REF_DATA), REF_DATA)).accrualPeriods(rap0, rap1, rap2, rap3, rap4).compoundingMethod(STRAIGHT).dayCount(ONE_ONE).currency(GBP).notional(1000d).build();
ResolvedSwapLeg expected = ResolvedSwapLeg.builder().paymentPeriods(rpp).payReceive(RECEIVE).type(SwapLegType.FIXED).build();
ResolvedSwapLeg testExpand = test.resolve(REF_DATA);
assertEquals(testExpand, expected);
}
public virtual void test_inflation_interpolated()
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, GBLO);
PeriodicSchedule accrualSchedule = PeriodicSchedule.builder().startDate(DATE_14_06_09).endDate(DATE_19_06_09).frequency(Frequency.ofYears(5)).businessDayAdjustment(bda).build();
PaymentSchedule paymentSchedule = PaymentSchedule.builder().paymentFrequency(Frequency.ofYears(5)).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).build();
InflationRateCalculation rateCalc = InflationRateCalculation.builder().index(GB_RPI).indexCalculationMethod(INTERPOLATED).lag(Period.ofMonths(3)).build();
NotionalSchedule notionalSchedule = NotionalSchedule.of(GBP, 1000d);
RateCalculationSwapLeg test = RateCalculationSwapLeg.builder().payReceive(RECEIVE).accrualSchedule(accrualSchedule).paymentSchedule(paymentSchedule).notionalSchedule(notionalSchedule).calculation(rateCalc).build();
assertEquals(test.StartDate, AdjustableDate.of(DATE_14_06_09, bda));
assertEquals(test.EndDate, AdjustableDate.of(DATE_19_06_09, bda));
assertEquals(test.Currency, GBP);
assertEquals(test.PayReceive, RECEIVE);
assertEquals(test.AccrualSchedule, accrualSchedule);
assertEquals(test.PaymentSchedule, paymentSchedule);
assertEquals(test.NotionalSchedule, notionalSchedule);
assertEquals(test.Calculation, rateCalc);
double weight = 1.0 - 9.0 / 30.0;
RatePaymentPeriod rpp0 = RatePaymentPeriod.builder().paymentDate(DaysAdjustment.ofBusinessDays(2, GBLO).adjust(bda.adjust(DATE_19_06_09, REF_DATA), REF_DATA)).accrualPeriods(RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09, REF_DATA)).endDate(bda.adjust(DATE_19_06_09, REF_DATA)).unadjustedStartDate(DATE_14_06_09).unadjustedEndDate(DATE_19_06_09).yearFraction(1.0).rateComputation(InflationInterpolatedRateComputation.of(GB_RPI, YearMonth.from(bda.adjust(DATE_14_06_09, REF_DATA)).minusMonths(3), YearMonth.from(bda.adjust(DATE_19_06_09, REF_DATA)).minusMonths(3), weight)).build()).dayCount(ONE_ONE).currency(GBP).notional(1000d).build();
ResolvedSwapLeg expected = ResolvedSwapLeg.builder().paymentPeriods(rpp0).payReceive(RECEIVE).type(SwapLegType.INFLATION).build();
ResolvedSwapLeg testExpand = test.resolve(REF_DATA);
assertEquals(testExpand, expected);
}
//-------------------------------------------------------------------------
// build conventions
private static FixedOvernightSwapConvention makeConvention(string name, OvernightIndex index, DayCount dayCount, Frequency frequency, int paymentLag, int spotLag)
{
HolidayCalendarId calendar = index.FixingCalendar;
DaysAdjustment paymentDateOffset = DaysAdjustment.ofBusinessDays(paymentLag, calendar);
DaysAdjustment spotDateOffset = DaysAdjustment.ofBusinessDays(spotLag, calendar);
return(ImmutableFixedOvernightSwapConvention.of(name, FixedRateSwapLegConvention.builder().currency(index.Currency).dayCount(dayCount).accrualFrequency(frequency).accrualBusinessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, calendar)).paymentFrequency(frequency).paymentDateOffset(paymentDateOffset).stubConvention(StubConvention.SMART_INITIAL).build(), OvernightRateSwapLegConvention.builder().index(index).accrualMethod(COMPOUNDED).accrualFrequency(frequency).paymentFrequency(frequency).paymentDateOffset(paymentDateOffset).stubConvention(StubConvention.SMART_INITIAL).build(), spotDateOffset));
}
public virtual void test_tiee()
{
assertEquals(FloatingRateName.of("MXN-TIIE").DefaultTenor, Tenor.TENOR_13W);
assertEquals(FloatingRateName.of("MXN-TIIE").toFloatingRateIndex(), IborIndices.MXN_TIIE_13W);
assertEquals(FloatingRateName.of("MXN-TIIE").toFloatingRateIndex(Tenor.TENOR_4W), IborIndices.MXN_TIIE_4W);
assertEquals(FloatingRateName.of("MXN-TIIE").toIborIndex(Tenor.TENOR_4W), IborIndices.MXN_TIIE_4W);
assertEquals(FloatingRateName.of("MXN-TIIE").toIborIndexFixingOffset(), DaysAdjustment.ofBusinessDays(-1, MXMC));
}
//-------------------------------------------------------------------------
public virtual void test_builder_ensureDefaults()
{
PaymentSchedule test = PaymentSchedule.builder().paymentFrequency(P1M).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).build();
assertEquals(test.PaymentFrequency, P1M);
assertEquals(test.BusinessDayAdjustment, null);
assertEquals(test.PaymentDateOffset, DaysAdjustment.ofBusinessDays(2, GBLO));
assertEquals(test.PaymentRelativeTo, PERIOD_END);
assertEquals(test.CompoundingMethod, NONE);
}
public virtual void test_expiry()
{
FxOptionVolatilitiesNode test = FxOptionVolatilitiesNode.of(EUR_GBP, SPOT_DATE_OFFSET, BDA, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_3M, STRIKE);
ZonedDateTime dateTime = LocalDate.of(2016, 1, 23).atStartOfDay(ZoneId.of("Europe/London"));
DaysAdjustment expAdj = DaysAdjustment.ofBusinessDays(-2, LO_TA);
double computed = test.timeToExpiry(dateTime, ACT_365F, REF_DATA);
double expected = ACT_365F.relativeYearFraction(dateTime.toLocalDate(), expAdj.adjust(BDA.adjust(SPOT_DATE_OFFSET.adjust(dateTime.toLocalDate(), REF_DATA).plus(Tenor.TENOR_3M), REF_DATA), REF_DATA));
assertEquals(computed, expected);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
XCcyIborIborSwapTemplate test = XCcyIborIborSwapTemplate.of(Period.ofMonths(3), TENOR_10Y, CONV);
coverImmutableBean(test);
DaysAdjustment bda2 = DaysAdjustment.ofBusinessDays(1, EUTA);
XCcyIborIborSwapConvention conv2 = ImmutableXCcyIborIborSwapConvention.of("XXX", USD3M, EUR3M, bda2);
XCcyIborIborSwapTemplate test2 = XCcyIborIborSwapTemplate.of(Period.ofMonths(2), TENOR_2Y, conv2);
coverBeanEquals(test, test2);
}
public virtual void test_builder_noExp()
{
FxOptionVolatilitiesNode test = FxOptionVolatilitiesNode.builder().currencyPair(EUR_GBP).label(LABEL).spotDateOffset(SPOT_DATE_OFFSET).businessDayAdjustment(BDA).quoteValueType(ValueType.BLACK_VOLATILITY).quoteId(QUOTE_ID).tenor(Tenor.TENOR_3M).strike(STRIKE).build();
assertEquals(test.BusinessDayAdjustment, BDA);
assertEquals(test.CurrencyPair, EUR_GBP);
assertEquals(test.Label, LABEL);
assertEquals(test.QuoteValueType, ValueType.BLACK_VOLATILITY);
assertEquals(test.SpotDateOffset, SPOT_DATE_OFFSET);
assertEquals(test.ExpiryDateOffset, DaysAdjustment.ofBusinessDays(-2, LO_TA));
assertEquals(test.Strike, STRIKE);
assertEquals(test.Tenor, Tenor.TENOR_3M);
}
public virtual void test_of()
{
FxOptionVolatilitiesNode test = FxOptionVolatilitiesNode.of(EUR_GBP, SPOT_DATE_OFFSET, BDA, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_3M, STRIKE);
assertEquals(test.BusinessDayAdjustment, BDA);
assertEquals(test.CurrencyPair, EUR_GBP);
assertEquals(test.Label, QUOTE_ID.ToString());
assertEquals(test.QuoteValueType, ValueType.BLACK_VOLATILITY);
assertEquals(test.SpotDateOffset, SPOT_DATE_OFFSET);
assertEquals(test.ExpiryDateOffset, DaysAdjustment.ofBusinessDays(-2, LO_TA));
assertEquals(test.Strike, STRIKE);
assertEquals(test.Tenor, Tenor.TENOR_3M);
}
public virtual void test_bbsw6m()
{
IborIndex test = IborIndex.of("AUD-BBSW-6M");
assertEquals(test.Currency, AUD);
assertEquals(test.Name, "AUD-BBSW-6M");
assertEquals(test.Tenor, TENOR_6M);
assertEquals(test.FixingCalendar, AUSY);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-1, AUSY));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(1, AUSY));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_6M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING_BI_MONTHLY, AUSY)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.ToString(), "AUD-BBSW-6M");
}
public virtual void test_zar_jibar()
{
IborIndex test = IborIndex.of("ZAR-JIBAR-3M");
assertEquals(test.Currency, ZAR);
assertEquals(test.Name, "ZAR-JIBAR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, ZAJO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(PRECEDING, ZAJO)));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(FOLLOWING, ZAJO)));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, ZAJO)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.ToString(), "ZAR-JIBAR-3M");
}
public virtual void test_expiry_standard()
{
DaysAdjustment spotLag = DaysAdjustment.ofBusinessDays(2, LO_NY);
BusinessDayAdjustment bda = BusinessDayAdjustment.of(BusinessDayConventions.FOLLOWING, LO_NY);
FxOptionVolatilitiesNode[] nodes = new FxOptionVolatilitiesNode[] { FxOptionVolatilitiesNode.of(GBP_USD, spotLag, bda, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_2M, STRIKE), FxOptionVolatilitiesNode.of(GBP_USD, spotLag, bda, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_10M, STRIKE), FxOptionVolatilitiesNode.of(GBP_USD, spotLag, bda, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_4M, STRIKE) };
ZonedDateTime[] valDates = new ZonedDateTime[] { LocalDate.of(2017, 10, 25).atStartOfDay(ZoneId.of("Europe/London")), LocalDate.of(2017, 10, 25).atStartOfDay(ZoneId.of("Europe/London")), LocalDate.of(2017, 10, 27).atStartOfDay(ZoneId.of("Europe/London")) };
LocalDate[] expDates = new LocalDate[] { LocalDate.of(2017, 12, 21), LocalDate.of(2018, 8, 23), LocalDate.of(2018, 2, 26) };
for (int i = 0; i < expDates.Length; ++i)
{
double computed = nodes[i].timeToExpiry(valDates[i], ACT_365F, REF_DATA);
double expected = ACT_365F.relativeYearFraction(valDates[i].toLocalDate(), expDates[i]);
assertEquals(computed, expected);
}
}
public virtual void test_pln_wibor()
{
IborIndex test = IborIndex.of("PLN-WIBOR-3M");
assertEquals(test.Currency, PLN);
assertEquals(test.Name, "PLN-WIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, PLWA);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, PLWA));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, PLWA));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, PLWA)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_ACT_ISDA);
assertEquals(test.ToString(), "PLN-WIBOR-3M");
}
public virtual void test_mxn_tiie()
{
IborIndex test = IborIndex.of("MXN-TIIE-4W");
assertEquals(test.Currency, MXN);
assertEquals(test.Name, "MXN-TIIE-4W");
assertEquals(test.Tenor, TENOR_4W);
assertEquals(test.FixingCalendar, MXMC);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-1, MXMC));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(1, MXMC));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_4W, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(FOLLOWING, MXMC)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, ACT_360);
assertEquals(test.ToString(), "MXN-TIIE-4W");
}
public virtual void test_sek_stibor()
{
IborIndex test = IborIndex.of("SEK-STIBOR-3M");
assertEquals(test.Currency, SEK);
assertEquals(test.Name, "SEK-STIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, SEST);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, SEST));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, SEST));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SEST)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, THIRTY_U_360);
assertEquals(test.ToString(), "SEK-STIBOR-3M");
}
public virtual void test_euribor3m()
{
IborIndex test = IborIndex.of("EUR-EURIBOR-3M");
assertEquals(test.Currency, EUR);
assertEquals(test.Name, "EUR-EURIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, EUTA);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, EUTA));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, EUTA));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, EUTA)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, THIRTY_U_360);
assertEquals(test.FloatingRateName, FloatingRateName.of("EUR-EURIBOR"));
assertEquals(test.ToString(), "EUR-EURIBOR-3M");
}
public virtual void test_tibor_euroyen3m()
{
IborIndex test = IborIndex.of("JPY-TIBOR-EUROYEN-3M");
assertEquals(test.Currency, JPY);
assertEquals(test.Name, "JPY-TIBOR-EUROYEN-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, JPTO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, JPTO));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, JPTO));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, JPTO)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.FloatingRateName, FloatingRateName.of("JPY-TIBOR-EUROYEN"));
assertEquals(test.ToString(), "JPY-TIBOR-EUROYEN-3M");
}
//-------------------------------------------------------------------------
public virtual void test_usdLibor3m()
{
IborIndex test = IborIndex.of("USD-LIBOR-3M");
assertEquals(test.Currency, USD);
assertEquals(test.Name, "USD-LIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, GBLO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, GBLO));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, GBLO, BusinessDayAdjustment.of(FOLLOWING, GBLO.combinedWith(USNY))));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO.combinedWith(USNY))));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, ACT_360);
assertEquals(test.FloatingRateName, FloatingRateName.of("USD-LIBOR"));
assertEquals(test.ToString(), "USD-LIBOR-3M");
}
public virtual void test_sgd_sibor()
{
HolidayCalendarId SGSI = HolidayCalendarId.of("SGSI");
IborIndex test = IborIndex.of("SGD-SIBOR-3M");
assertEquals(test.Currency, SGD);
assertEquals(test.Name, "SGD-SIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, SGSI);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, SGSI));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, SGSI));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SGSI)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.ToString(), "SGD-SIBOR-3M");
}
private static readonly HolidayCalendarId NZBD = HolidayCalendarId.of("NZBD"); // no constant for this
public virtual void test_gbpLibor3m()
{
IborIndex test = IborIndex.of("GBP-LIBOR-3M");
assertEquals(test.Name, "GBP-LIBOR-3M");
assertEquals(test.Currency, GBP);
assertEquals(test.Active, true);
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, GBLO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(PRECEDING, GBLO)));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(FOLLOWING, GBLO)));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.FloatingRateName, FloatingRateName.of("GBP-LIBOR"));
assertEquals(test.ToString(), "GBP-LIBOR-3M");
}
public virtual void test_of()
{
ImmutableCdsConvention test = ImmutableCdsConvention.of(NAME, GBP, ACT_365F, P3M, BUSI_ADJ, SETTLE_DAY_ADJ);
assertEquals(test.BusinessDayAdjustment, BUSI_ADJ);
assertEquals(test.StartDateBusinessDayAdjustment, BUSI_ADJ);
assertEquals(test.EndDateBusinessDayAdjustment, BusinessDayAdjustment.NONE);
assertEquals(test.Currency, GBP);
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.Name, NAME);
assertEquals(test.PaymentFrequency, P3M);
assertEquals(test.PaymentOnDefault, PaymentOnDefault.ACCRUED_PREMIUM);
assertEquals(test.ProtectionStart, ProtectionStartOfDay.BEGINNING);
assertEquals(test.RollConvention, RollConventions.DAY_20);
assertEquals(test.SettlementDateOffset, SETTLE_DAY_ADJ);
assertEquals(test.StepinDateOffset, DaysAdjustment.ofCalendarDays(1));
assertEquals(test.StubConvention, StubConvention.SMART_INITIAL);
}
public virtual void test_builder()
{
ImmutableCdsConvention test = ImmutableCdsConvention.builder().businessDayAdjustment(BUSI_ADJ).startDateBusinessDayAdjustment(BusinessDayAdjustment.NONE).endDateBusinessDayAdjustment(BUSI_ADJ).currency(GBP).dayCount(ACT_365F).name(NAME).paymentFrequency(P6M).paymentOnDefault(PaymentOnDefault.NONE).protectionStart(ProtectionStartOfDay.NONE).rollConvention(RollConventions.NONE).settlementDateOffset(DaysAdjustment.ofCalendarDays(7)).stepinDateOffset(DaysAdjustment.NONE).stubConvention(StubConvention.LONG_INITIAL).build();
assertEquals(test.BusinessDayAdjustment, BUSI_ADJ);
assertEquals(test.StartDateBusinessDayAdjustment, BusinessDayAdjustment.NONE);
assertEquals(test.EndDateBusinessDayAdjustment, BUSI_ADJ);
assertEquals(test.Currency, GBP);
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.Name, NAME);
assertEquals(test.PaymentFrequency, P6M);
assertEquals(test.PaymentOnDefault, PaymentOnDefault.NONE);
assertEquals(test.ProtectionStart, ProtectionStartOfDay.NONE);
assertEquals(test.RollConvention, RollConventions.NONE);
assertEquals(test.SettlementDateOffset, DaysAdjustment.ofCalendarDays(7));
assertEquals(test.StepinDateOffset, DaysAdjustment.NONE);
assertEquals(test.StubConvention, StubConvention.LONG_INITIAL);
}
public virtual void test_of_method()
{
OvernightRateSwapLegConvention test = OvernightRateSwapLegConvention.of(GBP_SONIA, P12M, 2, AVERAGED);
assertEquals(test.Index, GBP_SONIA);
assertEquals(test.AccrualMethod, AVERAGED);
assertEquals(test.RateCutOffDays, 0);
assertEquals(test.Currency, GBP);
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.AccrualFrequency, P12M);
assertEquals(test.AccrualBusinessDayAdjustment, BDA_MOD_FOLLOW);
assertEquals(test.StartDateBusinessDayAdjustment, BDA_MOD_FOLLOW);
assertEquals(test.EndDateBusinessDayAdjustment, BDA_MOD_FOLLOW);
assertEquals(test.StubConvention, StubConvention.SMART_INITIAL);
assertEquals(test.RollConvention, RollConventions.EOM);
assertEquals(test.PaymentFrequency, P12M);
assertEquals(test.PaymentDateOffset, DaysAdjustment.ofBusinessDays(2, GBP_SONIA.FixingCalendar));
assertEquals(test.CompoundingMethod, CompoundingMethod.NONE);
}
public virtual void test_krw_cd()
{
HolidayCalendarId KRSE = HolidayCalendarId.of("KRSE");
IborIndex test = IborIndex.of("KRW-CD-13W");
assertEquals(test.Currency, KRW);
assertEquals(test.Name, "KRW-CD-13W");
assertEquals(test.Tenor, TENOR_13W);
assertEquals(test.FixingCalendar, KRSE);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-1, KRSE));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(1, KRSE));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_13W, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(FOLLOWING, KRSE)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.ToString(), "KRW-CD-13W");
IborIndex test2 = IborIndex.of("KRW-CD-3M");
assertEquals(test2.Name, "KRW-CD-13W");
}
private Trade parseNdf(FpmlDocument document, XmlElement fxEl, XmlElement ndfEl, CurrencyAmount curr1Amount, CurrencyAmount curr2Amount, LocalDate valueDate, TradeInfoBuilder tradeInfoBuilder)
{
// rate
XmlElement rateEl = fxEl.getChild("exchangeRate");
double rate = document.parseDecimal(rateEl.getChild("rate"));
XmlElement pairEl = rateEl.getChild("quotedCurrencyPair");
Currency curr1 = document.parseCurrency(pairEl.getChild("currency1"));
Currency curr2 = document.parseCurrency(pairEl.getChild("currency2"));
string basis = pairEl.getChild("quoteBasis").Content;
FxRate fxRate;
if ("Currency2PerCurrency1".Equals(basis))
{
fxRate = FxRate.of(curr1, curr2, rate);
}
else if ("Currency1PerCurrency2".Equals(basis))
{
fxRate = FxRate.of(curr2, curr1, rate);
}
else
{
throw new FpmlParseException("Unknown quote basis: " + basis);
}
// settlement currency
Currency settleCurr = document.parseCurrency(ndfEl.getChild("settlementCurrency"));
CurrencyAmount settleCurrAmount = curr1Amount.Currency.Equals(settleCurr) ? curr1Amount : curr2Amount;
// index
XmlElement fixingEl = ndfEl.getChild("fixing"); // only support one of these in pricing model
LocalDate fixingDate = document.parseDate(fixingEl.getChild("fixingDate"));
DaysAdjustment offset = DaysAdjustment.ofCalendarDays(Math.toIntExact(valueDate.until(fixingDate, DAYS)));
XmlElement sourceEl = fixingEl.getChild("fxSpotRateSource"); // required for our model
XmlElement primarySourceEl = sourceEl.getChild("primaryRateSource");
string primarySource = primarySourceEl.getChild("rateSource").Content;
string primaryPage = primarySourceEl.findChild("rateSourcePage").map(e => e.Content).orElse("");
LocalTime time = document.parseTime(sourceEl.getChild("fixingTime").getChild("hourMinuteTime")); // required for our model
HolidayCalendarId calendar = document.parseBusinessCenter(sourceEl.getChild("fixingTime").getChild("businessCenter"));
FxIndex index = ImmutableFxIndex.builder().name(primarySource + "/" + primaryPage + "/" + time).currencyPair(CurrencyPair.of(curr1, curr2)).fixingCalendar(calendar).maturityDateOffset(offset).build();
return(FxNdfTrade.builder().info(tradeInfoBuilder.build()).product(FxNdf.builder().settlementCurrencyNotional(settleCurrAmount).agreedFxRate(fxRate).index(index).paymentDate(valueDate).build()).build());
}
//-------------------------------------------------------------------------
public virtual void test_ecb_eur_gbp_dates()
{
FxIndex test = FxIndices.EUR_GBP_ECB;
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, EUTA.combinedWith(GBLO)));
assertEquals(test.MaturityDateOffset, DaysAdjustment.ofBusinessDays(2, EUTA.combinedWith(GBLO)));
assertEquals(test.calculateMaturityFromFixing(date(2014, 10, 13), REF_DATA), date(2014, 10, 15));
assertEquals(test.calculateFixingFromMaturity(date(2014, 10, 15), REF_DATA), date(2014, 10, 13));
// weekend
assertEquals(test.calculateMaturityFromFixing(date(2014, 10, 16), REF_DATA), date(2014, 10, 20));
assertEquals(test.calculateFixingFromMaturity(date(2014, 10, 20), REF_DATA), date(2014, 10, 16));
assertEquals(test.calculateMaturityFromFixing(date(2014, 10, 17), REF_DATA), date(2014, 10, 21));
assertEquals(test.calculateFixingFromMaturity(date(2014, 10, 21), REF_DATA), date(2014, 10, 17));
// input date is Sunday
assertEquals(test.calculateMaturityFromFixing(date(2014, 10, 19), REF_DATA), date(2014, 10, 22));
assertEquals(test.calculateFixingFromMaturity(date(2014, 10, 19), REF_DATA), date(2014, 10, 16));
// skip maturity over EUR (1st May) and GBP (5th May) holiday
assertEquals(test.calculateMaturityFromFixing(date(2014, 4, 30), REF_DATA), date(2014, 5, 6));
assertEquals(test.calculateFixingFromMaturity(date(2014, 5, 6), REF_DATA), date(2014, 4, 30));
// resolve
assertEquals(test.resolve(REF_DATA).apply(date(2014, 5, 6)), FxIndexObservation.of(test, date(2014, 5, 6), REF_DATA));
}
public virtual void test_volatilities()
{
BlackFxOptionSmileVolatilitiesSpecification @base = BlackFxOptionSmileVolatilitiesSpecification.builder().name(VOL_NAME).currencyPair(EUR_GBP).dayCount(ACT_360).nodes(NODES).timeInterpolator(PCHIP).strikeInterpolator(PCHIP).build();
LocalDate date = LocalDate.of(2017, 9, 25);
ZonedDateTime dateTime = date.atStartOfDay().atZone(ZoneId.of("Europe/London"));
DoubleArray parameters = DoubleArray.of(0.05, -0.05, 0.15, 0.25, 0.1, -0.1);
BlackFxOptionSmileVolatilities computed = @base.volatilities(dateTime, parameters, REF_DATA);
LocalDate spotDate = SPOT_OFFSET.adjust(dateTime.toLocalDate(), REF_DATA);
DaysAdjustment expOffset = DaysAdjustment.ofBusinessDays(-2, TA_LO);
DoubleArray expiries = DoubleArray.of(ACT_360.relativeYearFraction(date, expOffset.adjust(BUS_ADJ.adjust(spotDate.plus(Tenor.TENOR_3M), REF_DATA), REF_DATA)), ACT_360.relativeYearFraction(date, expOffset.adjust(BUS_ADJ.adjust(spotDate.plus(Tenor.TENOR_1Y), REF_DATA), REF_DATA)));
SmileDeltaTermStructure smiles = InterpolatedStrikeSmileDeltaTermStructure.of(expiries, DoubleArray.of(0.1), DoubleArray.of(0.25, 0.15), DoubleMatrix.ofUnsafe(new double[][]
{
new double[] { -0.1 },
new double[] { -0.05 }
}), DoubleMatrix.ofUnsafe(new double[][]
{
new double[] { 0.1 },
new double[] { 0.05 }
}), ACT_360, PCHIP, FLAT, FLAT, PCHIP, FLAT, FLAT);
BlackFxOptionSmileVolatilities expected = BlackFxOptionSmileVolatilities.of(VOL_NAME, EUR_GBP, dateTime, smiles);
assertEquals(computed, expected);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
TermDepositTemplate test1 = TermDepositTemplate.of(DEPOSIT_PERIOD, CONVENTION);
coverImmutableBean(test1);
TermDepositTemplate test2 = TermDepositTemplate.of(Period.ofMonths(6), ImmutableTermDepositConvention.of("GBP-Dep", GBP, BDA_MOD_FOLLOW, ACT_365F, DaysAdjustment.ofBusinessDays(2, GBLO)));
coverBeanEquals(test1, test2);
}
public virtual void test_positive_offset()
{
assertThrows(() => Bill.builder().dayCount(DAY_COUNT).legalEntityId(LEGAL_ENTITY).notional(NOTIONAL).securityId(SECURITY_ID).settlementDateOffset(DaysAdjustment.ofBusinessDays(-11, USNY, BUSINESS_ADJUST)).yieldConvention(YIELD_CONVENTION).build());
}
