//------------------------------------------------------------------------- // 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()); }