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()); }
//------------------------------------------------------------------------- /// <summary> /// Calculates the forecast value of the FRA product. /// <para> /// The forecast value of the product is the value on the valuation date without present value discounting. /// /// </para> /// </summary> /// <param name="fra"> the product </param> /// <param name="provider"> the rates provider </param> /// <returns> the forecast value of the product </returns> public virtual CurrencyAmount forecastValue(ResolvedFra fra, RatesProvider provider) { double fv = forecastValue0(fra, provider); return(CurrencyAmount.of(fra.Currency, fv)); }
public virtual void test_builder_fail() { assertThrowsIllegalArg(() => BillSecurity.builder().dayCount(DAY_COUNT).info(INFO).legalEntityId(LEGAL_ENTITY).notional(NOTIONAL).settlementDateOffset(DaysAdjustment.ofBusinessDays(-1, USNY, BUSINESS_ADJUST)).yieldConvention(YIELD_CONVENTION).build()); assertThrowsIllegalArg(() => BillSecurity.builder().dayCount(DAY_COUNT).info(INFO).legalEntityId(LEGAL_ENTITY).notional(AdjustablePayment.of(CurrencyAmount.of(CCY, -2_000_000), MATURITY_DATE_ADJ)).settlementDateOffset(SETTLE).yieldConvention(YIELD_CONVENTION).build()); }
//------------------------------------------------------------------------- public virtual void regression_pv() { CurrencyAmount pv = PRICER.presentValue(FUTURE_TRADE, RATE_PROVIDER, HW_PROVIDER, LAST_PRICE); assertEquals(pv.Amount, 23383.551159035414, NOTIONAL * QUANTITY * TOL); }
public virtual void current_cash_vd() { CurrencyAmount ccTrade = PRICER_TRADE.currentCash(SWAPTION_PRETOD_LONG_REC, VAL_DATE); assertEquals(ccTrade.Amount, -PREMIUM_AMOUNT, TOLERANCE_PV); }
internal static FxVanillaOptionTrade sut2() { AdjustablePayment premium = AdjustablePayment.of(CurrencyAmount.of(EUR, NOTIONAL * 0.01), date(2014, 11, 13)); return(FxVanillaOptionTrade.builder().product(PRODUCT2).premium(premium).build()); }
//------------------------------------------------------------------------- /// <summary> /// Calculates the present value theta of the Ibor cap/floor product. /// <para> /// The present value of the product is the sensitivity value on the valuation date. /// </para> /// <para> /// The cap/floor leg and pay leg are typically in the same currency, thus the /// present value gamma is expressed as a single currency amount in most cases. /// /// </para> /// </summary> /// <param name="capFloor"> the Ibor cap/floor product </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="volatilities"> the volatilities </param> /// <returns> the present value theta </returns> public virtual MultiCurrencyAmount presentValueTheta(ResolvedIborCapFloor capFloor, RatesProvider ratesProvider, IborCapletFloorletVolatilities volatilities) { CurrencyAmount pvCapFloorLeg = capFloorLegPricer.presentValueTheta(capFloor.CapFloorLeg, ratesProvider, volatilities); return(MultiCurrencyAmount.of(pvCapFloorLeg)); }
//------------------------------------------------------------------------- public virtual void test_parSpreadSensitivity_noFixing() { PointSensitivities computedNoFix = PRICER.parSpreadSensitivity(RDEPOSIT, IMM_PROV_NOFIX); CurrencyParameterSensitivities sensiComputedNoFix = IMM_PROV_NOFIX.parameterSensitivity(computedNoFix); CurrencyParameterSensitivities sensiExpected = CAL_FD.sensitivity(IMM_PROV_NOFIX, (p) => CurrencyAmount.of(EUR, PRICER.parSpread(RDEPOSIT, (p)))); assertTrue(sensiComputedNoFix.equalWithTolerance(sensiExpected, TOLERANCE_RATE_DELTA)); // Par rate and par spread sensitivities are equal PointSensitivities computedParRateNoFix = PRICER.parRateSensitivity(RDEPOSIT, IMM_PROV_NOFIX); CurrencyParameterSensitivities sensiComputedParRateNoFix = IMM_PROV_NOFIX.parameterSensitivity(computedParRateNoFix); assertTrue(sensiComputedNoFix.equalWithTolerance(sensiComputedParRateNoFix, TOLERANCE_RATE_DELTA)); PointSensitivities computedFix = PRICER.parSpreadSensitivity(RDEPOSIT, IMM_PROV_FIX); CurrencyParameterSensitivities sensiComputedFix = IMM_PROV_NOFIX.parameterSensitivity(computedFix); assertTrue(sensiComputedFix.equalWithTolerance(sensiExpected, TOLERANCE_RATE_DELTA)); }
public virtual void test_currentCash_past() { assertEquals(PRICER.currentCash(TRADE_PAST, PROVIDER), CurrencyAmount.zero(USD)); }
public virtual void test_currentCash_onEndDate() { RatesProvider prov = ImmutableRatesProvider.builder(RDEPOSIT_TRADE.Product.EndDate).discountCurve(EUR, CURVE).build(); assertEquals(PRICER_TRADE.currentCash(RDEPOSIT_TRADE, prov), CurrencyAmount.of(EUR, NOTIONAL + INTEREST)); }
public virtual void test_currentCash_otherDate() { assertEquals(PRICER_TRADE.currentCash(RDEPOSIT_TRADE, IMM_PROV), CurrencyAmount.zero(EUR)); }
public virtual void test_resolve_knownAmountStub() { // test case CurrencyAmount knownAmount = CurrencyAmount.of(GBP, 150d); RateCalculationSwapLeg test = RateCalculationSwapLeg.builder().payReceive(PAY).accrualSchedule(PeriodicSchedule.builder().startDate(DATE_02_03).endDate(DATE_04_03).firstRegularStartDate(DATE_02_05).lastRegularEndDate(DATE_03_05).frequency(P1M).stubConvention(StubConvention.BOTH).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(P1M).paymentDateOffset(PLUS_TWO_DAYS).build()).notionalSchedule(NotionalSchedule.of(GBP, 1000d)).calculation(FixedRateCalculation.builder().dayCount(ACT_365F).rate(ValueSchedule.of(0.025d)).initialStub(FixedRateStubCalculation.ofKnownAmount(knownAmount)).finalStub(FixedRateStubCalculation.ofFixedRate(0.1d)).build()).build(); // expected KnownAmountNotionalSwapPaymentPeriod pp1 = KnownAmountNotionalSwapPaymentPeriod.builder().payment(Payment.of(knownAmount, DATE_02_07)).startDate(DATE_02_03).endDate(DATE_02_05).unadjustedStartDate(DATE_02_03).notionalAmount(CurrencyAmount.of(GBP, -1000d)).build(); RatePaymentPeriod rpp2 = RatePaymentPeriod.builder().paymentDate(DATE_03_07).accrualPeriods(RateAccrualPeriod.builder().startDate(DATE_02_05).endDate(DATE_03_05).yearFraction(ACT_365F.yearFraction(DATE_02_05, DATE_03_05)).rateComputation(FixedRateComputation.of(0.025d)).build()).dayCount(ACT_365F).currency(GBP).notional(-1000d).build(); RatePaymentPeriod rpp3 = RatePaymentPeriod.builder().paymentDate(DATE_04_07).accrualPeriods(RateAccrualPeriod.builder().startDate(DATE_03_05).endDate(DATE_04_03).unadjustedEndDate(DATE_04_03).yearFraction(ACT_365F.yearFraction(DATE_03_05, DATE_04_03)).rateComputation(FixedRateComputation.of(0.1d)).build()).dayCount(ACT_365F).currency(GBP).notional(-1000d).build(); // assertion assertEquals(test.resolve(REF_DATA), ResolvedSwapLeg.builder().type(FIXED).payReceive(PAY).paymentPeriods(pp1, rpp2, rpp3).build()); }
//------------------------------------------------------------------------- public virtual void test_resolve() { // test case KnownAmountSwapLeg test = KnownAmountSwapLeg.builder().payReceive(PAY).accrualSchedule(PeriodicSchedule.builder().startDate(DATE_01_05).endDate(DATE_04_05).frequency(P1M).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(P1M).paymentDateOffset(PLUS_TWO_DAYS).build()).amount(ValueSchedule.builder().initialValue(123d).steps(ValueStep.of(1, ValueAdjustment.ofReplace(234d))).build()).currency(GBP).build(); // expected KnownAmountSwapPaymentPeriod rpp1 = KnownAmountSwapPaymentPeriod.builder().payment(Payment.ofPay(CurrencyAmount.of(GBP, 123d), DATE_02_07)).startDate(DATE_01_06).endDate(DATE_02_05).unadjustedStartDate(DATE_01_05).build(); KnownAmountSwapPaymentPeriod rpp2 = KnownAmountSwapPaymentPeriod.builder().payment(Payment.ofPay(CurrencyAmount.of(GBP, 234d), DATE_03_07)).startDate(DATE_02_05).endDate(DATE_03_05).build(); KnownAmountSwapPaymentPeriod rpp3 = KnownAmountSwapPaymentPeriod.builder().payment(Payment.ofPay(CurrencyAmount.of(GBP, 234d), DATE_04_09)).startDate(DATE_03_05).endDate(DATE_04_07).unadjustedEndDate(DATE_04_05).build(); // assertion assertEquals(test.resolve(REF_DATA), ResolvedSwapLeg.builder().type(FIXED).payReceive(PAY).paymentPeriods(rpp1, rpp2, rpp3).build()); }
internal static SwaptionTrade sut2() { return(SwaptionTrade.builder().premium(AdjustablePayment.of(CurrencyAmount.of(Currency.USD, -3050000d), LocalDate.of(2014, 3, 17))).product(SwaptionTest.sut2()).build()); }
public virtual void test_dirtyPriceSensitivity() { PointSensitivityBuilder point = PRICER.dirtyPriceSensitivity(PRODUCT, PROVIDER, REF_DATA); CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point.build()); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, p => CurrencyAmount.of(EUR, PRICER.dirtyPriceFromCurves(PRODUCT, p, REF_DATA))); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * EPS)); }
public virtual void test_presentValue_provider_ended() { CurrencyAmount computed = PRICER.presentValue(TRADE_PAST, PROVIDER); assertEquals(computed, CurrencyAmount.zero(USD)); }
public virtual void test_dirtyPriceSensitivityWithZspread_periodic() { PointSensitivityBuilder point = PRICER.dirtyPriceSensitivityWithZspread(PRODUCT, PROVIDER, REF_DATA, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR); CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point.build()); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, p => CurrencyAmount.of(EUR, PRICER.dirtyPriceFromCurvesWithZSpread(PRODUCT, p, REF_DATA, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR))); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * EPS)); }
//------------------------------------------------------------------------- public virtual void test_priceSensitivity() { PointSensitivities point = FUTURE_PRICER.priceSensitivity(FUTURE_PRODUCT, PROVIDER); CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => CurrencyAmount.of(USD, FUTURE_PRICER.price(FUTURE_PRODUCT, (p)))); assertTrue(computed.equalWithTolerance(expected, EPS * 10.0)); }
public virtual void test_currentCash_zero() { assertEquals(PRICER_TRADE.currentCash(OPTION_TRADE, VAL_DATE), CurrencyAmount.zero(PREMIUM.Currency)); }
public virtual void test_priceSensitivityWithZSpread_continuous() { PointSensitivities point = FUTURE_PRICER.priceSensitivityWithZSpread(FUTURE_PRODUCT, PROVIDER, Z_SPREAD, CONTINUOUS, 0); CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, (p) => CurrencyAmount.of(USD, FUTURE_PRICER.priceWithZSpread(FUTURE_PRODUCT, (p), Z_SPREAD, CONTINUOUS, 0))); assertTrue(computed.equalWithTolerance(expected, EPS * 10.0)); }
public virtual void test_parSpreadSensitivity() { PointSensitivities point = PRICER.parSpreadSensitivityRates(FUTURE_TRADE, RATE_PROVIDER, HW_PROVIDER); CurrencyParameterSensitivities computed = RATE_PROVIDER.parameterSensitivity(point); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(RATE_PROVIDER, p => CurrencyAmount.of(EUR, PRICER.parSpread(FUTURE_TRADE, p, HW_PROVIDER, LAST_PRICE))); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * QUANTITY * TOL_FD)); }
//------------------------------------------------------------------------- /// <summary> /// Calculates the currency exposure by discounting each payment in its own currency. /// </summary> /// <param name="ndf"> the product </param> /// <param name="provider"> the rates provider </param> /// <returns> the currency exposure </returns> public virtual MultiCurrencyAmount currencyExposure(ResolvedFxNdf ndf, RatesProvider provider) { if (provider.ValuationDate.isAfter(ndf.PaymentDate)) { return(MultiCurrencyAmount.empty()); } Currency ccySettle = ndf.SettlementCurrency; CurrencyAmount notionalSettle = ndf.SettlementCurrencyNotional; double dfSettle = provider.discountFactor(ccySettle, ndf.PaymentDate); Currency ccyOther = ndf.NonDeliverableCurrency; double agreedRate = ndf.AgreedFxRate.fxRate(ccySettle, ccyOther); double dfOther = provider.discountFactor(ccyOther, ndf.PaymentDate); return(MultiCurrencyAmount.of(notionalSettle.multipliedBy(dfSettle)).plus(CurrencyAmount.of(ccyOther, -notionalSettle.Amount * agreedRate * dfOther))); }
public virtual void test_parSpreadSensitivity() { PointSensitivities computed = PRICER.parSpreadSensitivity(RTERM_DEPOSIT, IMM_PROV); CurrencyParameterSensitivities sensiComputed = IMM_PROV.parameterSensitivity(computed); CurrencyParameterSensitivities sensiExpected = CAL_FD.sensitivity(IMM_PROV, (p) => CurrencyAmount.of(EUR, PRICER.parSpread(RTERM_DEPOSIT, (p)))); assertTrue(sensiComputed.equalWithTolerance(sensiExpected, NOTIONAL * EPS_FD)); }
//------------------------------------------------------------------------- public virtual void coverage() { ResolvedFxSingleBarrierOptionTrade test1 = ResolvedFxSingleBarrierOptionTrade.builder().info(TRADE_INFO).product(PRODUCT).premium(PREMIUM).build(); ResolvedFxSingleBarrierOptionTrade test2 = ResolvedFxSingleBarrierOptionTrade.builder().product(ResolvedFxSingleBarrierOption.of(VANILLA_OPTION, BARRIER)).premium(Payment.of(CurrencyAmount.of(EUR, NOTIONAL * 0.01), date(2014, 11, 13))).build(); coverImmutableBean(test1); coverBeanEquals(test1, test2); }
public virtual void current_cash_past() { CurrencyAmount ccTrade = PRICER_TRADE.currentCash(SWAPTION_PREPAST_LONG_REC, VAL_DATE); assertEquals(ccTrade.Amount, 0, TOLERANCE_PV); }
//------------------------------------------------------------------------- public virtual MultiCurrencyAmount currencyExposure(KnownAmountSwapPaymentPeriod period, RatesProvider provider) { return(MultiCurrencyAmount.of(CurrencyAmount.of(period.Currency, presentValue(period, provider)))); }
//------------------------------------------------------------------------- public virtual void coverage() { BillSecurity test1 = BillSecurity.builder().dayCount(DAY_COUNT).info(INFO).legalEntityId(LEGAL_ENTITY).notional(NOTIONAL).settlementDateOffset(SETTLE).yieldConvention(YIELD_CONVENTION).build(); coverImmutableBean(test1); BillSecurity test2 = BillSecurity.builder().dayCount(DayCounts.ACT_365F).info(SecurityInfo.of(SecurityId.of("OG-Test", "ID2"), PRICE_INFO)).legalEntityId(LegalEntityId.of("OG-Ticker", "LE2")).notional(AdjustablePayment.of(CurrencyAmount.of(CCY, 10), MATURITY_DATE_ADJ)).settlementDateOffset(DaysAdjustment.ofBusinessDays(2, EUTA, BUSINESS_ADJUST)).yieldConvention(BillYieldConvention.INTEREST_AT_MATURITY).build(); coverBeanEquals(test1, test2); }
//------------------------------------------------------------------------- /// <summary> /// Calculates the current cash of the leg. /// </summary> /// <param name="cmsLeg"> the CMS leg </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="swaptionVolatilities"> the swaption volatilities </param> /// <returns> the current cash </returns> public virtual CurrencyAmount currentCash(ResolvedCmsLeg cmsLeg, RatesProvider ratesProvider, SabrSwaptionVolatilities swaptionVolatilities) { validate(ratesProvider, swaptionVolatilities); return(cmsLeg.CmsPeriods.Where(x => x.PaymentDate.Equals(ratesProvider.ValuationDate)).Select(x => cmsPeriodPricer.presentValue(x, ratesProvider, swaptionVolatilities)).Aggregate((c1, c2) => c1.plus(c2)).orElse(CurrencyAmount.zero(cmsLeg.Currency))); }
public virtual void test_builder_invalid() { assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(PAYMENT_2014_10_03).endDate(DATE_2014_10_01).notionalAmount(GBP_P50000).build()); assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(PAYMENT_2014_10_03).startDate(DATE_2014_10_01).notionalAmount(GBP_P50000).build()); assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(PAYMENT_2014_10_03).startDate(DATE_2014_10_01).endDate(DATE_2014_10_01).notionalAmount(GBP_P50000).build()); assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(PAYMENT_2014_10_03).startDate(DATE_2014_03_30).endDate(DATE_2014_10_01).notionalAmount(CurrencyAmount.of(USD, 1000d)).build()); assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(PAYMENT_2014_10_03).startDate(DATE_2014_03_30).endDate(DATE_2014_10_01).notionalAmount(CurrencyAmount.of(GBP, 1000d)).fxResetObservation(FX_RESET).build()); assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(PAYMENT_2014_10_03).startDate(DATE_2014_03_30).endDate(DATE_2014_10_01).notionalAmount(CurrencyAmount.of(EUR, 1000d)).fxResetObservation(FX_RESET).build()); assertThrowsIllegalArg(() => KnownAmountNotionalSwapPaymentPeriod.builder().payment(Payment.of(CurrencyAmount.of(EUR, 1000d), DATE_2014_10_03)).startDate(DATE_2014_03_30).endDate(DATE_2014_10_01).notionalAmount(CurrencyAmount.of(USD, 1000d)).fxResetObservation(FX_RESET).build()); }
private CurrencyAmount presentValueFromProductPresentValue(ResolvedFixedCouponBondTrade trade, LegalEntityDiscountingProvider provider, CurrencyAmount productPresentValue) { CurrencyAmount pvProduct = productPresentValue.multipliedBy(trade.Quantity); CurrencyAmount pvPayment = presentValuePayment(trade, provider); return(pvProduct.plus(pvPayment)); }