/** * Obtains a zero amount instance of {@code CurrencyAmount} for the specified currency. * * @param currency the currency the amount is in * @return the zero amount instance */ public static CurrencyAmount zero(Currency currency) { return of(currency, 0d); }
/** * Gets the amount at the specified index. * * @param index the zero-based index to retrieve * @return the amount at the specified index */ public CurrencyAmount get(int index) { return CurrencyAmount.of(currency, values.get(index)); }
public void test_collector_parallel() { List<CurrencyAmount> amount = ImmutableList.of( CurrencyAmount.of(CCY1, 100), CurrencyAmount.of(CCY1, 150), CurrencyAmount.of(CCY2, 100)); MultiCurrencyAmount test = amount.parallelStream().collect(toMultiCurrencyAmount()); MultiCurrencyAmount expected = MultiCurrencyAmount.of(CurrencyAmount.of(CCY1, 250), CurrencyAmount.of(CCY2, 100)); assertEquals(test, expected); }
public void test_minus_CurrencyAmount_merge() { CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117); CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12); CurrencyAmount cc = CurrencyAmount.of(Currency.AUD, 3); MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb); MultiCurrencyAmount test = mc1.minus(cc); assertMCA(test, cb, CurrencyAmount.of(Currency.AUD, 114)); }
public void test_plus_CurrencyAmount_add() { CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117); CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12); CurrencyAmount cc = CurrencyAmount.of(Currency.NZD, 3); MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb); MultiCurrencyAmount test = mc1.plus(cc); assertMCA(test, ca, cb, cc); }
public void test_minus_CurrencyDouble_add() { CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117); CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12); MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb); MultiCurrencyAmount test = mc1.minus(Currency.NZD, 3); assertMCA(test, ca, cb, CurrencyAmount.of(Currency.NZD, -3)); }
public void test_presentValue_withCurrency_past() { SwapPaymentPeriodPricer<SwapPaymentPeriod> mockPeriod = mock(SwapPaymentPeriodPricer.class); SwapPaymentEventPricer<SwapPaymentEvent> mockEvent = mock(SwapPaymentEventPricer.class); DiscountingSwapLegPricer test = new DiscountingSwapLegPricer(mockPeriod, mockEvent); CurrencyAmount expected = CurrencyAmount.of(USD, 0d); assertEquals(test.presentValue(IBOR_SWAP_LEG_REC_GBP, USD, MOCK_PROV_FUTURE), expected); }
public void test_of_String() { CurrencyAmount test = CurrencyAmount.of("USD", AMT1); assertEquals(test.getCurrency(), Currency.USD); assertEquals(test.getAmount(), AMT1, 0); }
public void noConversionNecessary() { FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63)); ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates); List<CurrencyAmount> values = ImmutableList.of( CurrencyAmount.of(Currency.GBP, 1), CurrencyAmount.of(Currency.GBP, 2), CurrencyAmount.of(Currency.GBP, 3)); DefaultScenarioArray<CurrencyAmount> test = DefaultScenarioArray.of(values); ScenarioArray<?> convertedList = test.convertedTo(Currency.GBP, fxProvider); ScenarioArray<CurrencyAmount> expectedList = DefaultScenarioArray.of(values); assertThat(convertedList).isEqualTo(expectedList); }
public void test_accruedInterest_firstAccrualPeriod() { RatesProvider prov = new MockRatesProvider(IBOR_RATE_PAYMENT_PERIOD_REC_GBP.getStartDate().plusDays(7)); SwapPaymentPeriodPricer<SwapPaymentPeriod> mockPeriod = mock(SwapPaymentPeriodPricer.class); when(mockPeriod.accruedInterest(IBOR_RATE_PAYMENT_PERIOD_REC_GBP, prov)) .thenReturn(1000d); SwapPaymentEventPricer<SwapPaymentEvent> mockEvent = mock(SwapPaymentEventPricer.class); DiscountingSwapLegPricer test = new DiscountingSwapLegPricer(mockPeriod, mockEvent); CurrencyAmount expected = CurrencyAmount.of(GBP, 1000d); assertEquals(test.accruedInterest(IBOR_SWAP_LEG_REC_GBP, prov), expected); }
public void test_currentCash_onPayment() { double rate = 1111.2; LocalDate paymentDate = NDF.getPaymentDate(); RatesProvider provider = RatesProviderFxDataSets.createProvider(paymentDate, NDF.getIndex(), rate); CurrencyAmount computed = PRICER.currentCash(NDF, provider); assertEquals(computed, CurrencyAmount.of(NDF.getSettlementCurrency(), NOMINAL_USD * (1d - FX_RATE / rate))); } }
public void test_presentValue_started() { ResolvedFxSwap product = ResolvedFxSwap.ofForwardPoints( CurrencyAmount.of(USD, NOMINAL_USD), KRW, FX_RATE, FX_FWD_POINTS, PAYMENT_DATE_PAST, PAYMENT_DATE_NEAR); MultiCurrencyAmount computed = PRICER.presentValue(product, PROVIDER); double expected_usd = -NOMINAL_USD * PROVIDER.discountFactor(USD, PAYMENT_DATE_NEAR); double expected_krw = NOMINAL_USD * (FX_RATE + FX_FWD_POINTS) * PROVIDER.discountFactor(KRW, PAYMENT_DATE_NEAR); assertEquals(computed.getAmount(USD).getAmount(), expected_usd, NOMINAL_USD * TOL); assertEquals(computed.getAmount(KRW).getAmount(), expected_krw, NOMINAL_USD * FX_RATE * TOL); // currency exposure MultiCurrencyAmount exposure = PRICER.currencyExposure(product, PROVIDER); assertEquals(exposure, computed); }
public void test_presentValueSensitivity_events() { ResolvedSwapLeg expSwapLeg = IBOR_SWAP_LEG_REC_GBP; PointSensitivities point = PRICER_LEG.presentValueSensitivityEventsInternal(expSwapLeg, RATES_GBP).build(); CurrencyParameterSensitivities psAd = RATES_GBP.parameterSensitivity(point); CurrencyParameterSensitivities psFd = FINITE_DIFFERENCE_CALCULATOR.sensitivity(RATES_GBP, (p) -> CurrencyAmount.of(GBP, PRICER_LEG.presentValueEventsInternal(expSwapLeg, p))); assertTrue(psAd.equalWithTolerance(psFd, TOLERANCE_DELTA)); }
public void test_dirtyPriceSensitivityWithZspread_continuous() { PointSensitivityBuilder point = PRICER.dirtyPriceSensitivityWithZspread(PRODUCT, PROVIDER, REF_DATA, Z_SPREAD, CONTINUOUS, 0); CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point.build()); CurrencyParameterSensitivities expected = FD_CAL.sensitivity(PROVIDER, p -> CurrencyAmount.of( EUR, PRICER.dirtyPriceFromCurvesWithZSpread(PRODUCT, p, REF_DATA, Z_SPREAD, CONTINUOUS, 0))); assertTrue(computed.equalWithTolerance(expected, NOTIONAL * EPS)); }
public void test_resolveTarget() { SecurityPosition position = sut(); GenericSecurity resolvedSecurity = GenericSecurity.of(SecurityInfo.of(SECURITY_ID, 1, CurrencyAmount.of(USD, 0.01))); ImmutableReferenceData refData = ImmutableReferenceData.of(SECURITY_ID, resolvedSecurity); GenericSecurityPosition expected = GenericSecurityPosition.ofLongShort(POSITION_INFO, resolvedSecurity, LONG_QUANTITY, SHORT_QUANTITY); assertEquals(position.resolveTarget(refData), expected); }
public void test_parSpreadSensitivity_iborIbor() { ResolvedSwap expanded = SWAP_USD_LIBOR_3M_LIBOR_6M_5Y.getProduct().resolve(REF_DATA); PointSensitivities point = SWAP_PRODUCT_PRICER.parSpreadSensitivity(expanded, MULTI_USD).build(); CurrencyParameterSensitivities prAd = MULTI_USD.parameterSensitivity(point); CurrencyParameterSensitivities prFd = FINITE_DIFFERENCE_CALCULATOR.sensitivity( MULTI_USD, p -> CurrencyAmount.of(USD, SWAP_PRODUCT_PRICER.parSpread(expanded, p))); assertTrue(prAd.equalWithTolerance(prFd, TOLERANCE_RATE_DELTA)); }
public void test_negated() { MultiCurrencyAmount base = MultiCurrencyAmount.of(CA1, CA2); MultiCurrencyAmount test = base.negated(); assertMCA(test, CA1.negated(), CA2.negated()); assertEquals( MultiCurrencyAmount.of(CurrencyAmount.zero(Currency.USD), CurrencyAmount.zero(Currency.EUR)).negated(), MultiCurrencyAmount.of(CurrencyAmount.zero(Currency.USD), CurrencyAmount.zero(Currency.EUR))); assertEquals( MultiCurrencyAmount.of(CurrencyAmount.of(Currency.USD, -0d), CurrencyAmount.of(Currency.EUR, -0d)).negated(), MultiCurrencyAmount.of(CurrencyAmount.zero(Currency.USD), CurrencyAmount.zero(Currency.EUR))); }
public void test_parSpreadSensitivity_iborCmpIbor_1Period() { ResolvedSwap swap = USD_LIBOR_3M_LIBOR_6M .createTrade(MULTI_USD.getValuationDate(), Tenor.TENOR_6M, BUY, NOTIONAL_SWAP, SPREAD, REF_DATA).resolve(REF_DATA).getProduct(); PointSensitivities point = SWAP_PRODUCT_PRICER.parSpreadSensitivity(swap, MULTI_USD).build(); CurrencyParameterSensitivities prAd = MULTI_USD.parameterSensitivity(point); CurrencyParameterSensitivities prFd = FINITE_DIFFERENCE_CALCULATOR.sensitivity( MULTI_USD, p -> CurrencyAmount.of(USD, SWAP_PRODUCT_PRICER.parSpread(swap, p))); assertTrue(prAd.equalWithTolerance(prFd, TOLERANCE_RATE_DELTA)); }
public void test_pvbpSensitivity() { ResolvedSwapLeg leg = ResolvedSwapLeg.builder() .type(FIXED) .payReceive(PAY) .paymentPeriods(FIXED_RATE_PAYMENT_PERIOD_PAY_USD, FIXED_RATE_PAYMENT_PERIOD_PAY_USD_2) .build(); PointSensitivities point = PRICER_LEG.pvbpSensitivity(leg, RATES_USD).build(); CurrencyParameterSensitivities pvbpsAd = RATES_USD.parameterSensitivity(point); CurrencyParameterSensitivities pvbpsFd = FINITE_DIFFERENCE_CALCULATOR.sensitivity(RATES_USD, (p) -> CurrencyAmount.of(USD, PRICER_LEG.pvbp(leg, p))); assertTrue(pvbpsAd.equalWithTolerance(pvbpsFd, TOLERANCE_DELTA)); }
public void test_beanBuilder_invalid() { BeanBuilder<? extends MultiCurrencyAmount> test = MultiCurrencyAmount.meta().builder() .set(MultiCurrencyAmount.meta().amounts(), ImmutableSortedSet.of(CA1, CA2, CurrencyAmount.of(CA1.getCurrency(), AMT3))); assertThrowsIllegalArg(() -> test.build()); }