Refine search
public void test_merge_size1_stub() { Schedule test = Schedule.builder() .periods(ImmutableList.of(P1_STUB)) .frequency(P1M) .rollConvention(DAY_17) .build(); assertEquals(test.mergeRegular(2, true), test); assertEquals(test.mergeRegular(2, false), test); assertEquals(test.merge(2, P1_STUB.getUnadjustedStartDate(), P1_STUB.getUnadjustedEndDate()), test); assertEquals(test.merge(2, P1_STUB.getStartDate(), P1_STUB.getEndDate()), test); }
public void test_ofTerm() { Schedule test = Schedule.ofTerm(P1_STUB); assertEquals(test.size(), 1); assertEquals(test.isTerm(), true); assertEquals(test.isSinglePeriod(), true); assertEquals(test.getFrequency(), TERM); assertEquals(test.getRollConvention(), RollConventions.NONE); assertEquals(test.isEndOfMonthConvention(), false); assertEquals(test.getPeriods(), ImmutableList.of(P1_STUB)); assertEquals(test.getPeriod(0), P1_STUB); assertEquals(test.getStartDate(), P1_STUB.getStartDate()); assertEquals(test.getEndDate(), P1_STUB.getEndDate()); assertEquals(test.getUnadjustedStartDate(), P1_STUB.getUnadjustedStartDate()); assertEquals(test.getUnadjustedEndDate(), P1_STUB.getUnadjustedEndDate()); assertEquals(test.getFirstPeriod(), P1_STUB); assertEquals(test.getLastPeriod(), P1_STUB); assertEquals(test.getInitialStub(), Optional.empty()); assertEquals(test.getFinalStub(), Optional.empty()); assertEquals(test.getRegularPeriods(), ImmutableList.of(P1_STUB)); assertThrows(() -> test.getPeriod(1), IndexOutOfBoundsException.class); assertEquals(test.getUnadjustedDates(), ImmutableList.of(JUL_04, JUL_17)); }
/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(Schedule beanToCopy) { this.periods = beanToCopy.getPeriods(); this.frequency = beanToCopy.getFrequency(); this.rollConvention = beanToCopy.getRollConvention(); }
/** * Resolves the value and adjustments against a specific schedule. * <p> * This converts a schedule into a list of values, one for each schedule period. * * @param schedule the schedule * @return the values, one for each schedule period */ public DoubleArray resolveValues(Schedule schedule) { return resolveValues(schedule.getPeriods(), schedule.getRollConvention()); }
@Override public ImmutableList<RateAccrualPeriod> createAccrualPeriods( Schedule accrualSchedule, Schedule paymentSchedule, ReferenceData refData) { // resolve data by schedule DoubleArray resolvedGearings = firstNonNull(gearing, ALWAYS_1).resolveValues(accrualSchedule); // build accrual periods ImmutableList.Builder<RateAccrualPeriod> accrualPeriods = ImmutableList.builder(); for (int i = 0; i < accrualSchedule.size(); i++) { SchedulePeriod period = accrualSchedule.getPeriod(i); // inflation does not use a day count, so year fraction is 1d accrualPeriods.add(new RateAccrualPeriod( period, 1d, createRateComputation(period, i), resolvedGearings.get(i), 0d, NegativeRateMethod.ALLOW_NEGATIVE)); } return accrualPeriods.build(); }
public void test_expand_onePeriod_with_futureValueNotional() { FixedRateCalculation test = FixedRateCalculation.builder() .dayCount(ACT_365F) .rate(ValueSchedule.of(0.025d)) .futureValueNotional(FutureValueNotional.of(1000d)) .build(); SchedulePeriod period = SchedulePeriod.of(date(2014, 1, 6), date(2014, 2, 5), date(2014, 1, 5), date(2014, 2, 5)); Schedule schedule = Schedule.builder() .periods(period) .frequency(Frequency.TERM) .rollConvention(RollConventions.NONE) .build(); double yearFraction = period.yearFraction(ACT_365F, schedule); RateAccrualPeriod rap = RateAccrualPeriod.builder(period) .yearFraction(period.yearFraction(ACT_365F, schedule)) .rateComputation(FixedOvernightCompoundedAnnualRateComputation.of(0.025d, yearFraction)) .build(); ImmutableList<RateAccrualPeriod> periods = test.createAccrualPeriods(schedule, schedule, REF_DATA); assertEquals(periods, ImmutableList.of(rap)); }
@Override public ResolvedFixedCouponBond resolve(ReferenceData refData) { Schedule adjustedSchedule = accrualSchedule.createSchedule(refData); Schedule unadjustedSchedule = adjustedSchedule.toUnadjusted(); DateAdjuster exCouponPeriodAdjuster = exCouponPeriod.resolve(refData); ImmutableList.Builder<FixedCouponBondPaymentPeriod> accrualPeriods = ImmutableList.builder(); for (int i = 0; i < adjustedSchedule.size(); i++) { SchedulePeriod period = adjustedSchedule.getPeriod(i); SchedulePeriod unadjustedPeriod = unadjustedSchedule.getPeriod(i); accrualPeriods.add(FixedCouponBondPaymentPeriod.builder() .unadjustedStartDate(period.getUnadjustedStartDate()) FixedCouponBondPaymentPeriod lastPeriod = periodicPayments.get(periodicPayments.size() - 1); Payment nominalPayment = Payment.of(CurrencyAmount.of(currency, notional), lastPeriod.getPaymentDate()); return ResolvedFixedCouponBond.builder()
/** * Obtains a 'Term' instance based on a single period. * <p> * A 'Term' schedule has one period with a frequency of 'Term'. * * @param period the single period * @return the merged 'Term' schedule */ public static Schedule ofTerm(SchedulePeriod period) { ArgChecker.notNull(period, "period"); return Schedule.builder() .periods(ImmutableList.of(period)) .frequency(Frequency.TERM) .rollConvention(RollConventions.NONE) .build(); }
public void test_mergeToTerm() { Schedule testNormal = Schedule.builder() .periods(ImmutableList.of(P1_STUB, P2_NORMAL, P3_NORMAL)) .frequency(P1M) .rollConvention(DAY_17) .build(); assertEquals(testNormal.mergeToTerm(), Schedule.ofTerm(P1_3)); assertEquals(testNormal.mergeToTerm().mergeToTerm(), Schedule.ofTerm(P1_3)); }
Optional<SchedulePeriod> scheduleInitialStub = accrualSchedule.getInitialStub(); Optional<SchedulePeriod> scheduleFinalStub = accrualSchedule.getFinalStub(); if (accrualSchedule.size() != 1) { throw new IllegalArgumentException( "Invalid swap, only one accrual period allowed when future value notional is present"); SchedulePeriod period = accrualSchedule.getPeriod(0); double yearFraction = period.yearFraction(dayCount, accrualSchedule); double resolvedRate = resolvedRates.get(0); RateComputation rateComputation = FixedOvernightCompoundedAnnualRateComputation.of(resolvedRate, yearFraction); RateAccrualPeriod accrualPeriod = new RateAccrualPeriod(period, yearFraction, rateComputation); return ImmutableList.of(accrualPeriod); ImmutableList.Builder<RateAccrualPeriod> accrualPeriods = ImmutableList.builder(); for (int i = 0; i < accrualSchedule.size(); i++) { SchedulePeriod period = accrualSchedule.getPeriod(i); double yearFraction = period.yearFraction(dayCount, accrualSchedule);
ImmutableList.Builder<NotionalPaymentPeriod> paymentPeriods = ImmutableList.builder(); IntFunction<CurrencyAmount> notionalFunction = getNotionalSupplierFunction(notionalSchedule, notionals, payReceive); for (int index = 0; index < paymentSchedule.size(); index++) { SchedulePeriod period = paymentSchedule.getPeriod(index); CurrencyAmount notional = notionalFunction.apply(index); ImmutableList<RateAccrualPeriod> paymentAccrualPeriods = ImmutableList.of(accrualPeriods.get(index)); paymentPeriods.add(createPaymentPeriod( index, for (int paymentIndex = 0; paymentIndex < paymentSchedule.size(); paymentIndex++) { SchedulePeriod payPeriod = paymentSchedule.getPeriod(paymentIndex); CurrencyAmount notional = notionalFunction.apply(paymentIndex); int accrualStartIndex = accrualIndex;
public void test_isEndOfMonthConvention_eom() { // schedule doesn't make sense, but test only requires roll convention of EOM Schedule test = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL)) .frequency(P1M) .rollConvention(RollConventions.EOM) .build(); assertEquals(test.isEndOfMonthConvention(), true); }
public void test_getPeriodEndDate() { // schedule doesn't make sense, but test only requires roll convention of EOM Schedule test = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL)) .frequency(P1M) .rollConvention(DAY_17) .build(); assertEquals(test.getPeriodEndDate(P2_NORMAL.getStartDate()), P2_NORMAL.getEndDate()); assertEquals(test.getPeriodEndDate(P2_NORMAL.getStartDate().plusDays(1)), P2_NORMAL.getEndDate()); assertEquals(test.getPeriodEndDate(P3_NORMAL.getStartDate()), P3_NORMAL.getEndDate()); assertEquals(test.getPeriodEndDate(P3_NORMAL.getStartDate().plusDays(1)), P3_NORMAL.getEndDate()); assertThrowsIllegalArg(() -> test.getPeriodEndDate(P2_NORMAL.getStartDate().minusDays(1))); }
public void coverage_equals() { Schedule a = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL, P4_NORMAL, P5_NORMAL, P6_NORMAL)) .frequency(P1M) .rollConvention(DAY_17) .build(); Schedule b = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL)) .frequency(P1M) .rollConvention(DAY_17) .build(); Schedule c = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL, P4_NORMAL, P5_NORMAL, P6_NORMAL)) .frequency(P3M) .rollConvention(DAY_17) .build(); Schedule d = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL, P4_NORMAL, P5_NORMAL, P6_NORMAL)) .frequency(P1M) .rollConvention(RollConventions.DAY_1) .build(); assertEquals(a.equals(a), true); assertEquals(a.equals(b), false); assertEquals(a.equals(c), false); assertEquals(a.equals(d), false); }
public void test_toUnadjusted() { SchedulePeriod a = SchedulePeriod.of(JUL_17, OCT_17, JUL_16, OCT_15); SchedulePeriod b = SchedulePeriod.of(JUL_16, OCT_15, JUL_16, OCT_15); Schedule test = Schedule.builder() .periods(ImmutableList.of(a)) .frequency(P1M) .rollConvention(DAY_17) .build() .toUnadjusted(); Schedule expected = Schedule.builder() .periods(ImmutableList.of(b)) .frequency(P1M) .rollConvention(DAY_17) .build(); assertEquals(test, expected); }
public void test_merge_badDate() { Schedule test = Schedule.builder() .periods(ImmutableList.of(P2_NORMAL, P3_NORMAL, P4_NORMAL, P5_NORMAL, P6_NORMAL)) .frequency(P1M) .rollConvention(DAY_17) .build(); assertThrows(() -> test.merge(2, JUL_03, AUG_17), ScheduleException.class); assertThrows(() -> test.merge(2, JUL_17, SEP_30), ScheduleException.class); }
public void test_createSchedule_fullMerge() { PaymentSchedule test = PaymentSchedule.builder() .paymentFrequency(P3M) .paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)) .build(); Schedule schedule = test.createSchedule(ACCRUAL_SCHEDULE, REF_DATA); Schedule expected = Schedule.builder() .periods(SchedulePeriod.of(DATE_01_06, DATE_04_07, DATE_01_05, DATE_04_05)) .frequency(P3M) .rollConvention(DAY_5) .build(); assertEquals(schedule, expected); }
public void test_accruedInterest() { LocalDate refDate = LocalDate.of(2014, 6, 10); double computed = PRODUCT.accruedInterest(refDate); Schedule sch = SCHEDULE.createSchedule(REF_DATA).toUnadjusted(); CapitalIndexedBondPaymentPeriod period = PRODUCT.getPeriodicPayments().get(16); double factor = ACT_ACT_ICMA.relativeYearFraction(period.getUnadjustedStartDate(), refDate, sch); assertEquals(computed, factor * REAL_COUPON_VALUE * NOTIONAL * 2d, TOL * REAL_COUPON_VALUE * NOTIONAL); }
public void test_resolve() { FixedCouponBond base = sut(); ResolvedFixedCouponBond resolved = base.resolve(REF_DATA); assertEquals(resolved.getLegalEntityId(), LEGAL_ENTITY); assertEquals(resolved.getSettlementDateOffset(), DATE_OFFSET); assertEquals(resolved.getYieldConvention(), YIELD_CONVENTION); ImmutableList<FixedCouponBondPaymentPeriod> periodicPayments = resolved.getPeriodicPayments(); int expNum = 20; assertEquals(periodicPayments.size(), expNum); LocalDate unadjustedEnd = END_DATE; Schedule unadjusted = PERIOD_SCHEDULE.createSchedule(REF_DATA).toUnadjusted(); for (int i = 0; i < expNum; ++i) { FixedCouponBondPaymentPeriod payment = periodicPayments.get(expNum - 1 - i); assertEquals(payment.getCurrency(), EUR); assertEquals(payment.getNotional(), NOTIONAL); assertEquals(payment.getFixedRate(), FIXED_RATE); assertEquals(payment.getUnadjustedEndDate(), unadjustedEnd); assertEquals(payment.getEndDate(), BUSINESS_ADJUST.adjust(unadjustedEnd, REF_DATA)); assertEquals(payment.getPaymentDate(), payment.getEndDate()); LocalDate unadjustedStart = unadjustedEnd.minusMonths(6); assertEquals(payment.getUnadjustedStartDate(), unadjustedStart); assertEquals(payment.getStartDate(), BUSINESS_ADJUST.adjust(unadjustedStart, REF_DATA)); assertEquals(payment.getYearFraction(), unadjusted.getPeriod(expNum - 1 - i).yearFraction(DAY_COUNT, unadjusted)); assertEquals(payment.getDetachmentDate(), EX_COUPON.adjust(payment.getPaymentDate(), REF_DATA)); unadjustedEnd = unadjustedStart; } Payment expectedPayment = Payment.of(CurrencyAmount.of(EUR, NOTIONAL), BUSINESS_ADJUST.adjust(END_DATE, REF_DATA)); assertEquals(resolved.getNominalPayment(), expectedPayment); }
public void test_subSchedule_2monthIn3Month_shortInitial() { SchedulePeriod test = SchedulePeriod.of(JUN_17, SEP_17); Schedule schedule = test.subSchedule(P2M, RollConventions.DAY_17, StubConvention.SHORT_INITIAL, BusinessDayAdjustment.NONE) .createSchedule(REF_DATA); assertEquals(schedule.size(), 2); assertEquals(schedule.getPeriod(0), SchedulePeriod.of(JUN_17, JUL_17)); assertEquals(schedule.getPeriod(1), SchedulePeriod.of(JUL_17, SEP_17)); assertEquals(schedule.getFrequency(), P2M); assertEquals(schedule.getRollConvention(), RollConventions.DAY_17); }