//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = BillTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); CurrencyAmount expectedPv = PRICER.presentValue(RTRADE, provider); MultiCurrencyAmount expectedCurrencyExposure = PRICER.currencyExposure(RTRADE, provider); CurrencyAmount expectedCurrentCash = PRICER.currentCash(RTRADE, provider.ValuationDate); assertEquals(CALC.presentValue(RTRADE, LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(CALC.currencyExposure(RTRADE, LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(CALC.currentCash(RTRADE, LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); assertEquals(CALC.presentValue(RTRADE, provider), expectedPv); assertEquals(CALC.currencyExposure(RTRADE, provider), expectedCurrencyExposure); assertEquals(CALC.currentCash(RTRADE, provider), expectedCurrentCash); }
//------------------------------------------------------------------------- // calculates current cash for all scenarios internal CurrencyScenarioArray currentCash(ResolvedSwaptionTrade trade, RatesScenarioMarketData ratesMarketData, SwaptionScenarioMarketData swaptionMarketData) { return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => currentCash(trade, ratesMarketData.scenario(i).ValuationDate))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = TermDepositTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); DiscountingTermDepositTradePricer pricer = DiscountingTermDepositTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider); double expectedParRate = pricer.parRate(RTRADE, provider); double expectedParSpread = pricer.parSpread(RTRADE, provider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider); CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider); assertEquals(TermDepositTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(TermDepositTradeCalculations.DEFAULT.parRate(RTRADE, RATES_LOOKUP, md), DoubleScenarioArray.of(ImmutableList.of(expectedParRate))); assertEquals(TermDepositTradeCalculations.DEFAULT.parSpread(RTRADE, RATES_LOOKUP, md), DoubleScenarioArray.of(ImmutableList.of(expectedParSpread))); assertEquals(TermDepositTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(TermDepositTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal static CurrencyScenarioArray presentValue(Security security, double quantity, ScenarioMarketData marketData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => calculatePresentValue(security, quantity, marketData.scenario(i)))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = BondFutureTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingBondFutureTradePricer pricer = DiscountingBondFutureTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, SETTLE_PRICE); double expectedParSpread = pricer.parSpread(RTRADE, provider, SETTLE_PRICE); assertEquals(BondFutureTradeCalculations.DEFAULT.presentValue(RTRADE, LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(BondFutureTradeCalculations.DEFAULT.parSpread(RTRADE, LOOKUP, md), DoubleScenarioArray.of(ImmutableList.of(expectedParSpread))); }
//------------------------------------------------------------------------- // calculates current cash for all scenarios internal CurrencyScenarioArray currentCash(ResolvedFxVanillaOptionTrade trade, RatesScenarioMarketData ratesMarketData, FxOptionScenarioMarketData optionMarketData, FxVanillaOptionMethod method) { return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => currentCash(trade, ratesMarketData.scenario(i).ValuationDate, method))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = FixedCouponBondTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingFixedCouponBondTradePricer pricer = DiscountingFixedCouponBondTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider); CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider.ValuationDate); assertEquals(FixedCouponBondTradeCalculations.DEFAULT.presentValue(RTRADE, LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(FixedCouponBondTradeCalculations.DEFAULT.currencyExposure(RTRADE, LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(FixedCouponBondTradeCalculations.DEFAULT.currentCash(RTRADE, LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal CurrencyScenarioArray presentValue(ResolvedIborFutureOptionTrade trade, RatesScenarioMarketData ratesMarketData, IborFutureOptionScenarioMarketData optionMarketData) { IborIndex index = trade.Product.UnderlyingFuture.Index; return(CurrencyScenarioArray.of(ratesMarketData.ScenarioCount, i => presentValue(trade, ratesMarketData.scenario(i).ratesProvider(), optionMarketData.scenario(i).volatilities(index)))); }
//------------------------------------------------------------------------- // calculates principal for all scenarios internal CurrencyScenarioArray principal(ResolvedCdsIndexTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => principal(trade, marketData.scenario(i).creditRatesProvider(), refData))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal CurrencyScenarioArray presentValue(ResolvedCdsIndexTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => presentValue(trade, marketData.scenario(i).creditRatesProvider(), PriceType.DIRTY, refData))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal CurrencyScenarioArray presentValue(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingScenarioMarketData legalEntityMarketData, BondFutureOptionScenarioMarketData optionMarketData) { SecurityId securityId = trade.Product.UnderlyingFuture.SecurityId; return(CurrencyScenarioArray.of(legalEntityMarketData.ScenarioCount, i => presentValue(trade, legalEntityMarketData.scenario(i).discountingProvider(), optionMarketData.scenario(i).volatilities(securityId)))); }
//------------------------------------------------------------------------- // calculates expected loss for all scenarios internal CurrencyScenarioArray expectedLoss(ResolvedCdsTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => expectedLoss(trade, marketData.scenario(i).creditRatesProvider()))); }
//------------------------------------------------------------------------- // calculates recovery01 for all scenarios internal CurrencyScenarioArray recovery01(ResolvedCdsTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => recovery01(trade, marketData.scenario(i).creditRatesProvider(), refData))); }
//------------------------------------------------------------------------- // calculates calibrated parallel IR01 for all scenarios internal CurrencyScenarioArray ir01CalibratedParallel(ResolvedCdsTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => ir01CalibratedParallel(trade, marketData.scenario(i).creditRatesProvider(), refData))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = BulletPaymentTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); DiscountingPaymentPricer pricer = DiscountingPaymentPricer.DEFAULT; Payment payment = RTRADE.Product.Payment; CurrencyAmount expectedPv = pricer.presentValue(payment, provider); CashFlows expectedCashFlows = pricer.cashFlows(payment, provider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(payment, provider); CurrencyAmount expectedCurrentCash = pricer.currentCash(payment, provider); assertEquals(BulletPaymentTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(BulletPaymentTradeCalculations.DEFAULT.cashFlows(RTRADE, RATES_LOOKUP, md), ScenarioArray.of(ImmutableList.of(expectedCashFlows))); assertEquals(BulletPaymentTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(BulletPaymentTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal CurrencyScenarioArray presentValue(ResolvedCapitalIndexedBondTrade trade, RatesScenarioMarketData ratesMarketData, LegalEntityDiscountingScenarioMarketData legalEntityMarketData) { return(CurrencyScenarioArray.of(legalEntityMarketData.ScenarioCount, i => presentValue(trade, ratesMarketData.scenario(i).ratesProvider(), legalEntityMarketData.scenario(i).discountingProvider()))); }
//------------------------------------------------------------------------- // calculates current cash for all scenarios internal virtual CurrencyScenarioArray currentCash(ResolvedBillTrade trade, LegalEntityDiscountingScenarioMarketData marketData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => currentCash(trade, marketData.scenario(i).discountingProvider()))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = CapitalIndexedBondTradeCalculationFunctionTest.marketData(); RatesProvider ratesProvider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); LegalEntityDiscountingProvider ledProvider = LED_LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingCapitalIndexedBondTradePricer pricer = DiscountingCapitalIndexedBondTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, ratesProvider, ledProvider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, ratesProvider, ledProvider); CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, ratesProvider); assertEquals(CapitalIndexedBondTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, LED_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(CapitalIndexedBondTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, LED_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(CapitalIndexedBondTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, LED_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- // calculates current cash for all scenarios internal CurrencyScenarioArray currentCash(ResolvedTermDepositTrade trade, RatesScenarioMarketData marketData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => currentCash(trade, marketData.scenario(i).ratesProvider()))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal CurrencyScenarioArray presentValue(ResolvedBondFutureTrade trade, LegalEntityDiscountingScenarioMarketData marketData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => presentValue(trade, marketData.scenario(i).discountingProvider()))); }
//------------------------------------------------------------------------- // calculates present value for all scenarios internal CurrencyScenarioArray presentValue(ResolvedFxNdfTrade trade, RatesScenarioMarketData marketData) { return(CurrencyScenarioArray.of(marketData.ScenarioCount, i => presentValue(trade, marketData.scenario(i).ratesProvider()))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = FxNdfTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); DiscountingFxNdfTradePricer pricer = DiscountingFxNdfTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider); CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider); FxRate expectedForwardFx = pricer.forwardFxRate(RTRADE, provider); assertEquals(FxNdfTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(FxNdfTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(FxNdfTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); assertEquals(FxNdfTradeCalculations.DEFAULT.forwardFxRate(RTRADE, RATES_LOOKUP, md), ScenarioArray.of(ImmutableList.of(expectedForwardFx))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = FxSingleBarrierOptionTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); BlackFxSingleBarrierOptionTradePricer pricer = BlackFxSingleBarrierOptionTradePricer.DEFAULT; MultiCurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, VOLS); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, VOLS); CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider.ValuationDate); assertEquals(FxSingleBarrierOptionTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, FX_OPTION_LOOKUP, md, BLACK), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(FxSingleBarrierOptionTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, FX_OPTION_LOOKUP, md, BLACK), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(FxSingleBarrierOptionTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, FX_OPTION_LOOKUP, md, BLACK), CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { CurrencyAmount expected = TRADE_PRICER.presentValue(RESOLVED_TRADE, RATES_PROVIDER, SETTLEMENT_PRICE); assertEquals(CALC.presentValue(RESOLVED_TRADE, RATES_LOOKUP, MARKET_DATA), CurrencyScenarioArray.of(ImmutableList.of(expected))); assertEquals(CALC.presentValue(RESOLVED_TRADE, RATES_PROVIDER), expected); }