private double accrualWithNotional(RatePaymentPeriod period, double notional, RatesProvider provider) { // handle simple case and more complex compounding for whole payment period if (period.getAccrualPeriods().size() == 1) { RateAccrualPeriod accrualPeriod = period.getAccrualPeriods().get(0); return unitNotionalAccrual(accrualPeriod, accrualPeriod.getSpread(), provider) * notional; } return accrueCompounded(period, notional, provider); }
private double compoundingNone(RatePaymentPeriod paymentPeriod, double notional, RatesProvider provider) { return paymentPeriod.getAccrualPeriods().stream() .mapToDouble(accrualPeriod -> unitNotionalAccrual(accrualPeriod, accrualPeriod.getSpread(), provider) * notional) .sum(); }
private Optional<FixedOvernightCompoundedAnnualRateComputation> findAnnualRateComputation(ResolvedSwapLeg fixedLeg) { SwapPaymentPeriod firstPeriod = fixedLeg.getPaymentPeriods().get(0); if (firstPeriod instanceof RatePaymentPeriod) { RatePaymentPeriod payment = (RatePaymentPeriod) firstPeriod; RateAccrualPeriod firstAccrualPeriod = payment.getAccrualPeriods().get(0); if (firstAccrualPeriod.getRateComputation() instanceof FixedOvernightCompoundedAnnualRateComputation) { return Optional.of((FixedOvernightCompoundedAnnualRateComputation) firstAccrualPeriod.getRateComputation()); } } return Optional.empty(); }
private double pvbpCompoundedFlat(RatePaymentPeriod paymentPeriod, RatesProvider provider) { int nbCmp = paymentPeriod.getAccrualPeriods().size(); double[] rate = paymentPeriod.getAccrualPeriods().stream() .mapToDouble(ap -> rawRate(ap, provider)) .toArray(); double df = provider.discountFactor(paymentPeriod.getCurrency(), paymentPeriod.getPaymentDate()); double rBar = 1.0; double[] cpaAccumulatedBar = new double[nbCmp + 1]; cpaAccumulatedBar[nbCmp] = paymentPeriod.getNotional() * df * rBar; double spreadBar = 0.0d; for (int j = nbCmp - 1; j >= 0; j--) { cpaAccumulatedBar[j] = (1.0d + paymentPeriod.getAccrualPeriods().get(j).getYearFraction() * rate[j] * paymentPeriod.getAccrualPeriods().get(j).getGearing()) * cpaAccumulatedBar[j + 1]; spreadBar += paymentPeriod.getAccrualPeriods().get(j).getYearFraction() * cpaAccumulatedBar[j + 1]; } return spreadBar; }
private double compoundedStraight(RatePaymentPeriod paymentPeriod, double notional, RatesProvider provider) { double notionalAccrued = notional; for (RateAccrualPeriod accrualPeriod : paymentPeriod.getAccrualPeriods()) { double investFactor = 1 + unitNotionalAccrual(accrualPeriod, accrualPeriod.getSpread(), provider); notionalAccrued *= investFactor; } return (notionalAccrued - notional); }
private LocalDate calculateLastFixingDate(LocalDate valuationDate, ReferenceData refData) { SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData); SwapLeg iborLeg = trade.getProduct().getLegs(SwapLegType.IBOR).get(0); ResolvedSwapLeg iborLegExpanded = iborLeg.resolve(refData); List<SwapPaymentPeriod> periods = iborLegExpanded.getPaymentPeriods(); int nbPeriods = periods.size(); RatePaymentPeriod lastPeriod = (RatePaymentPeriod) periods.get(nbPeriods - 1); List<RateAccrualPeriod> accruals = lastPeriod.getAccrualPeriods(); int nbAccruals = accruals.size(); IborRateComputation ibor = (IborRateComputation) accruals.get(nbAccruals - 1).getRateComputation(); return ibor.getFixingDate(); }
private LocalDate calculateLastFixingDate(LocalDate valuationDate, ReferenceData refData) { SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData); SwapLeg iborLeg = trade.getProduct().getLegs(SwapLegType.IBOR).get(0); ResolvedSwapLeg iborLegExpanded = iborLeg.resolve(refData); List<SwapPaymentPeriod> periods = iborLegExpanded.getPaymentPeriods(); int nbPeriods = periods.size(); RatePaymentPeriod lastPeriod = (RatePaymentPeriod) periods.get(nbPeriods - 1); List<RateAccrualPeriod> accruals = lastPeriod.getAccrualPeriods(); int nbAccruals = accruals.size(); IborRateComputation ibor = (IborRateComputation) accruals.get(nbAccruals - 1).getRateComputation(); return ibor.getFixingDate(); }
private LocalDate calculateLastFixingDate(LocalDate valuationDate, ReferenceData refData) { SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, 0, refData); SwapLeg iborLeg = trade.getProduct().getLegs(SwapLegType.IBOR).get(1); // Select the 'second' Ibor leg, i.e. the flat leg ResolvedSwapLeg iborLegExpanded = iborLeg.resolve(refData); List<SwapPaymentPeriod> periods = iborLegExpanded.getPaymentPeriods(); int nbPeriods = periods.size(); RatePaymentPeriod lastPeriod = (RatePaymentPeriod) periods.get(nbPeriods - 1); List<RateAccrualPeriod> accruals = lastPeriod.getAccrualPeriods(); int nbAccruals = accruals.size(); IborRateComputation ibor = (IborRateComputation) accruals.get(nbAccruals - 1).getRateComputation(); return ibor.getFixingDate(); }
private LocalDate calculateLastFixingDate(LocalDate valuationDate, ReferenceData refData) { SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData); SwapLeg iborLeg = trade.getProduct().getLegs(SwapLegType.IBOR).get(1); // Select the 'second' leg, i.e. the flat leg ResolvedSwapLeg iborLegExpanded = iborLeg.resolve(refData); List<SwapPaymentPeriod> periods = iborLegExpanded.getPaymentPeriods(); int nbPeriods = periods.size(); RatePaymentPeriod lastPeriod = (RatePaymentPeriod) periods.get(nbPeriods - 1); List<RateAccrualPeriod> accruals = lastPeriod.getAccrualPeriods(); int nbAccruals = accruals.size(); IborRateComputation ibor = (IborRateComputation) accruals.get(nbAccruals - 1).getRateComputation(); return ibor.getFixingDate(); }
private LocalDate calculateLastFixingDate(LocalDate valuationDate, ReferenceData refData) { SwapTrade trade = template.createTrade(valuationDate, BuySell.BUY, 1, 1, refData); SwapLeg iborLeg = trade.getProduct().getLegs(SwapLegType.IBOR).get(1); // Select the 'second' Ibor leg, i.e. the flat floating leg ResolvedSwapLeg iborLegExpanded = iborLeg.resolve(refData); List<SwapPaymentPeriod> periods = iborLegExpanded.getPaymentPeriods(); int nbPeriods = periods.size(); RatePaymentPeriod lastPeriod = (RatePaymentPeriod) periods.get(nbPeriods - 1); List<RateAccrualPeriod> accruals = lastPeriod.getAccrualPeriods(); int nbAccruals = accruals.size(); IborRateComputation ibor = (IborRateComputation) accruals.get(nbAccruals - 1).getRateComputation(); return ibor.getFixingDate(); }
private double compoundedSpreadExclusive(RatePaymentPeriod paymentPeriod, double notional, RatesProvider provider) { double notionalAccrued = notional; double spreadAccrued = 0; for (RateAccrualPeriod accrualPeriod : paymentPeriod.getAccrualPeriods()) { double investFactor = 1 + unitNotionalAccrual(accrualPeriod, 0, provider); notionalAccrued *= investFactor; spreadAccrued += notional * accrualPeriod.getSpread() * accrualPeriod.getYearFraction(); } return (notionalAccrued - notional + spreadAccrued); }
/** * Calculates the strike. * * @param fixedLeg the fixed leg * @return the strike */ protected double calculateStrike(ResolvedSwapLeg fixedLeg) { SwapPaymentPeriod paymentPeriod = fixedLeg.getPaymentPeriods().get(0); ArgChecker.isTrue(paymentPeriod instanceof RatePaymentPeriod, "Payment period must be RatePaymentPeriod"); RatePaymentPeriod ratePaymentPeriod = (RatePaymentPeriod) paymentPeriod; // compounding is caught when par rate is computed RateComputation rateComputation = ratePaymentPeriod.getAccrualPeriods().get(0).getRateComputation(); ArgChecker.isTrue(rateComputation instanceof FixedRateComputation, "Swap leg must be fixed leg"); return ((FixedRateComputation) rateComputation).getRate(); }
private double compoundedFlat(RatePaymentPeriod paymentPeriod, double notional, RatesProvider provider) { double cpaAccumulated = 0d; for (RateAccrualPeriod accrualPeriod : paymentPeriod.getAccrualPeriods()) { double rate = rawRate(accrualPeriod, provider); cpaAccumulated += cpaAccumulated * unitNotionalAccrualRaw(accrualPeriod, rate, 0) + unitNotionalAccrualRaw(accrualPeriod, rate, accrualPeriod.getSpread()); } return cpaAccumulated * notional; }
private PointSensitivityBuilder unitNotionalSensitivityNoCompounding(RatePaymentPeriod period, RatesProvider provider) { Currency ccy = period.getCurrency(); PointSensitivityBuilder sensi = PointSensitivityBuilder.none(); for (RateAccrualPeriod accrualPeriod : period.getAccrualPeriods()) { sensi = sensi.combinedWith(unitNotionalSensitivityAccrual(accrualPeriod, ccy, provider)); } return sensi; }
/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(RatePaymentPeriod beanToCopy) { this.paymentDate = beanToCopy.getPaymentDate(); this.accrualPeriods = beanToCopy.getAccrualPeriods(); this.dayCount = beanToCopy.getDayCount(); this.currency = beanToCopy.getCurrency(); this.fxReset = beanToCopy.fxReset; this.notional = beanToCopy.getNotional(); this.compoundingMethod = beanToCopy.getCompoundingMethod(); }
public void test_pvbp_onePeriod() { RatesProvider mockProv = mock(RatesProvider.class); double df = 0.99d; when(mockProv.discountFactor(USD, FIXED_RATE_PAYMENT_PERIOD_PAY_USD.getPaymentDate())) .thenReturn(df); double expected = df * FIXED_RATE_PAYMENT_PERIOD_PAY_USD.getNotional() * FIXED_RATE_PAYMENT_PERIOD_PAY_USD.getAccrualPeriods().get(0).getYearFraction(); DiscountingSwapLegPricer test = DiscountingSwapLegPricer.DEFAULT; assertEquals(test.pvbp(FIXED_SWAP_LEG_PAY_USD, mockProv), expected, TOLERANCE); }
private PointSensitivityBuilder compoundedSpreadExclusiveSensitivity( RatePaymentPeriod paymentPeriod, RatesProvider provider) { double notionalAccrued = 1d; Currency ccy = paymentPeriod.getCurrency(); PointSensitivityBuilder sensi = PointSensitivityBuilder.none(); for (RateAccrualPeriod accrualPeriod : paymentPeriod.getAccrualPeriods()) { double investFactor = 1 + unitNotionalAccrual(accrualPeriod, 0, provider); notionalAccrued *= investFactor; PointSensitivityBuilder investFactorSensi = unitNotionalSensitivityAccrual(accrualPeriod, ccy, provider).multipliedBy(1d / investFactor); sensi = sensi.combinedWith(investFactorSensi); } return sensi.multipliedBy(notionalAccrued); }
public void test_builder_twoAccrualPeriods() { RatePaymentPeriod test = RatePaymentPeriod.builder() .paymentDate(DATE_2014_10_01) .accrualPeriods(RAP1, RAP2) .dayCount(ACT_365F) .currency(GBP) .notional(1000d) .compoundingMethod(CompoundingMethod.STRAIGHT) .build(); assertEquals(test.getStartDate(), DATE_2014_03_30); assertEquals(test.getEndDate(), DATE_2014_09_30); assertEquals(test.getPaymentDate(), DATE_2014_10_01); assertEquals(test.getAccrualPeriods(), ImmutableList.of(RAP1, RAP2)); assertEquals(test.getCurrency(), GBP); assertEquals(test.getFxReset(), Optional.empty()); assertEquals(test.getNotional(), 1000d, 0d); assertEquals(test.getCompoundingMethod(), CompoundingMethod.STRAIGHT); assertEquals(test.isCompoundingApplicable(), true); }
private PointSensitivityBuilder compoundedStraightSensitivity( RatePaymentPeriod paymentPeriod, RatesProvider provider) { double notionalAccrued = 1d; Currency ccy = paymentPeriod.getCurrency(); PointSensitivityBuilder sensi = PointSensitivityBuilder.none(); for (RateAccrualPeriod accrualPeriod : paymentPeriod.getAccrualPeriods()) { double investFactor = 1d + unitNotionalAccrual(accrualPeriod, accrualPeriod.getSpread(), provider); notionalAccrued *= investFactor; PointSensitivityBuilder investFactorSensi = unitNotionalSensitivityAccrual(accrualPeriod, ccy, provider).multipliedBy(1d / investFactor); sensi = sensi.combinedWith(investFactorSensi); } return sensi.multipliedBy(notionalAccrued); }
public void test_builder_oneAccrualPeriod() { RatePaymentPeriod test = RatePaymentPeriod.builder() .paymentDate(DATE_2014_10_01) .accrualPeriods(RAP2) .dayCount(ACT_365F) .currency(GBP) .notional(1000d) .compoundingMethod(CompoundingMethod.STRAIGHT) .build(); assertEquals(test.getStartDate(), DATE_2014_06_30); assertEquals(test.getEndDate(), DATE_2014_09_30); assertEquals(test.getPaymentDate(), DATE_2014_10_01); assertEquals(test.getAccrualPeriods(), ImmutableList.of(RAP2)); assertEquals(test.getCurrency(), GBP); assertEquals(test.getFxReset(), Optional.empty()); assertEquals(test.getNotional(), 1000d, 0d); assertEquals(test.getNotionalAmount(), CurrencyAmount.of(GBP, 1000d)); assertEquals(test.getCompoundingMethod(), CompoundingMethod.STRAIGHT); assertEquals(test.isCompoundingApplicable(), false); }