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); }
//------------------------------------------------------------------------- // 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_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_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 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 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_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_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_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_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_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_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_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_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"); }
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_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"); }
//------------------------------------------------------------------------- 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 test_serialization() { IborIndex index = ImmutableIborIndex.builder().name("Test-3M").currency(Currency.GBP).fixingCalendar(GBLO).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, GBLO)).effectiveDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).maturityDateOffset(TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.NONE)).dayCount(ACT_360).fixingTime(LocalTime.NOON).fixingZone(ZoneId.of("Europe/London")).build(); assertSerialization(index); }
//------------------------------------------------------------------------- public virtual void coverage() { ImmutableIborIndex index = ImmutableIborIndex.builder().name("Test-3M").currency(Currency.GBP).fixingCalendar(GBLO).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, GBLO)).effectiveDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).maturityDateOffset(TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.NONE)).dayCount(ACT_360).fixingTime(LocalTime.NOON).fixingZone(ZoneId.of("Europe/London")).build(); coverImmutableBean(index); coverPrivateConstructor(typeof(IborIndices)); }
//------------------------------------------------------------------------- public virtual void test_equals() { ImmutableIborIndex a = ImmutableIborIndex.builder().name("Test-3M").currency(Currency.GBP).fixingCalendar(GBLO).fixingDateOffset(DaysAdjustment.ofBusinessDays(-2, GBLO)).effectiveDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).maturityDateOffset(TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.NONE)).dayCount(ACT_360).fixingTime(LocalTime.NOON).fixingZone(ZoneId.of("Europe/London")).build(); IborIndex b = a.toBuilder().name("Rubbish-3M").build(); assertEquals(a.Equals(b), false); }
public virtual void test_serialization() { PaymentSchedule test = PaymentSchedule.builder().paymentFrequency(P3M).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).build(); assertSerialization(test); }
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()); }
//------------------------------------------------------------------------- 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 coverage() { ImmutableTermDepositConvention test1 = ImmutableTermDepositConvention.of("EUR-Deposit", EUR, BDA_MOD_FOLLOW, ACT_360, PLUS_TWO_DAYS); coverImmutableBean(test1); ImmutableTermDepositConvention test2 = ImmutableTermDepositConvention.of("GBP-Deposit", GBP, BDA_MOD_FOLLOW, ACT_365F, DaysAdjustment.ofBusinessDays(0, GBLO)); coverBeanEquals(test1, test2); coverPrivateConstructor(typeof(TermDepositConventions)); coverPrivateConstructor(typeof(StandardTermDepositConventions)); }