//------------------------------------------------------------------------- //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void test_presentValue() public virtual void test_presentValue() { ScenarioMarketData md = DsfTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); DiscountingDsfTradePricer pricer = DiscountingDsfTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, REF_PRICE); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, REF_PRICE); assertEquals(DsfTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(DsfTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = IborFutureTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); DiscountingIborFutureTradePricer pricer = DiscountingIborFutureTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, SETTLEMENT_PRICE); double expectedParSpread = pricer.parSpread(RTRADE, provider, SETTLEMENT_PRICE); assertEquals(IborFutureTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, md), CurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(IborFutureTradeCalculations.DEFAULT.parSpread(RTRADE, RATES_LOOKUP, md), DoubleScenarioArray.of(ImmutableList.of(expectedParSpread))); }
//------------------------------------------------------------------------- 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() { ScenarioMarketData md = IborCapFloorTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); VolatilityIborCapFloorTradePricer pricer = VolatilityIborCapFloorTradePricer.DEFAULT; MultiCurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, VOLS); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, VOLS); MultiCurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider, VOLS); assertEquals(IborCapFloorTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, SWAPTION_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(IborCapFloorTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, SWAPTION_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(IborCapFloorTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, SWAPTION_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- 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))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = FxSingleTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); DiscountingFxSingleTradePricer pricer = DiscountingFxSingleTradePricer.DEFAULT; MultiCurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider); MultiCurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider); FxRate expectedForwardFx = pricer.forwardFxRate(RTRADE, provider); assertEquals(FxSingleTradeCalculations.DEFAULT.presentValue(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(FxSingleTradeCalculations.DEFAULT.currencyExposure(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(FxSingleTradeCalculations.DEFAULT.currentCash(RTRADE, RATES_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); assertEquals(FxSingleTradeCalculations.DEFAULT.forwardFxRate(RTRADE, RATES_LOOKUP, md), ScenarioArray.of(ImmutableList.of(expectedForwardFx))); }
//------------------------------------------------------------------------- public virtual void test_presentValue() { ScenarioMarketData md = CmsTradeCalculationFunctionTest.marketData(); RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider(); SabrExtrapolationReplicationCmsTradePricer pricer = new SabrExtrapolationReplicationCmsTradePricer(new SabrExtrapolationReplicationCmsProductPricer(new SabrExtrapolationReplicationCmsLegPricer(SabrExtrapolationReplicationCmsPeriodPricer.of(CMS_MODEL.CutOffStrike, CMS_MODEL.Mu)))); MultiCurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider, VOLS); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider, VOLS); MultiCurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider, VOLS); CmsTradeCalculations calcs = CmsTradeCalculations.of(CMS_MODEL); assertEquals(calcs.presentValue(RTRADE, RATES_LOOKUP, SWAPTION_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv))); assertEquals(calcs.currencyExposure(RTRADE, RATES_LOOKUP, SWAPTION_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure))); assertEquals(calcs.currentCash(RTRADE, RATES_LOOKUP, SWAPTION_LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash))); }
//------------------------------------------------------------------------- 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))); }
//------------------------------------------------------------------------- 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))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates unit price across one or more scenarios. /// <para> /// This is the price of a single unit of the security. /// </para> /// <para> /// Strata uses <i>decimal prices</i> for DSFs in the trade model, pricers and market data. /// The decimal price is based on the decimal multiplier equivalent to the implied percentage. /// Thus the market price of 100.182 is represented in Strata by 1.00182. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value, one entry per scenario </returns> public virtual DoubleScenarioArray unitPrice(ResolvedDsfTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.unitPrice(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="swaptionLookup"> the lookup used to query the swaption market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray presentValue(ResolvedCmsTrade trade, RatesMarketDataLookup ratesLookup, SwaptionMarketDataLookup swaptionLookup, ScenarioMarketData marketData) { return(calc.presentValue(trade, ratesLookup.marketDataView(marketData), swaptionLookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Explains the present value calculation across one or more scenarios. /// <para> /// This provides a breakdown of how /// <seealso cref="#presentValue(ResolvedSwapTrade, RatesMarketDataLookup, ScenarioMarketData) present value"/> /// was calculated, typically used for debugging and validation. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value explanation, one entry per scenario </returns> public virtual ScenarioArray <ExplainMap> explainPresentValue(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.explainPresentValue(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates the present value of each leg across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value of each leg, one entry per scenario </returns> public virtual ScenarioArray <LegAmounts> legPresentValue(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.legPresentValue(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates cash flows across one or more scenarios. /// <para> /// The cash flows provide details about the payments of the trade. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the cash flows, one entry per scenario </returns> public virtual ScenarioArray <CashFlows> cashFlows(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.cashFlows(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedSwapTrade, RatesMarketDataLookup, ScenarioMarketData) present value"/> /// to a one basis point shift in the market quotes used to calibrate the curves. /// The result is provided for each affected curve and currency, bucketed by curve node. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual ScenarioArray <CurrencyParameterSensitivities> pv01MarketQuoteBucketed(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.pv01MarketQuoteBucketed(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates unit price across one or more scenarios. /// <para> /// This is the price of a single unit of the security. /// </para> /// <para> /// Strata uses <i>decimal prices</i> for Ibor futures in the trade model, pricers and market data. /// The decimal price is based on the decimal rate equivalent to the percentage. /// For example, a price of 99.32 implies an interest rate of 0.68% which is represented in Strata by 0.9932. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the rates market data </param> /// <param name="optionLookup"> the lookup used to query the option market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value, one entry per scenario </returns> public virtual DoubleScenarioArray unitPrice(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData) { return(calc.unitPrice(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedIborFutureOptionTrade, RatesMarketDataLookup, IborFutureOptionMarketDataLookup, ScenarioMarketData) present value"/> /// to a one basis point shift in the market quotes used to calibrate the curves. /// The result is the sum of the sensitivities of all affected curves. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the rates market data </param> /// <param name="optionLookup"> the lookup used to query the option market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray pv01MarketQuoteSum(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData) { return(calc.pv01MarketQuoteSum(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedIborFutureOptionTrade, RatesMarketDataLookup, IborFutureOptionMarketDataLookup, ScenarioMarketData) present value"/> /// to a one basis point shift in the calibrated curves. /// The result is provided for each affected curve and currency, bucketed by curve node. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the rates market data </param> /// <param name="optionLookup"> the lookup used to query the option market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual ScenarioArray <CurrencyParameterSensitivities> pv01CalibratedBucketed(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData) { return(calc.pv01CalibratedBucketed(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedIborFutureTrade, RatesMarketDataLookup, ScenarioMarketData) present value"/> /// to a one basis point shift in the calibrated curves. /// The result is the sum of the sensitivities of all affected curves. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray pv01CalibratedSum(ResolvedIborFutureTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.pv01CalibratedSum(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates currency exposure across one or more scenarios. /// <para> /// The currency risk, expressed as the equivalent amount in each currency. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the currency exposure, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray currencyExposure(ResolvedDsfTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.currencyExposure(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedSwapTrade, RatesMarketDataLookup, ScenarioMarketData) present value"/> /// to a one basis point shift in the market quotes used to calibrate the curves. /// The result is the sum of the sensitivities of all affected curves. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray pv01MarketQuoteSum(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.pv01MarketQuoteSum(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the rates market data </param> /// <param name="optionLookup"> the lookup used to query the option market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value, one entry per scenario </returns> public virtual CurrencyScenarioArray presentValue(ResolvedIborFutureOptionTrade trade, RatesMarketDataLookup ratesLookup, IborFutureOptionMarketDataLookup optionLookup, ScenarioMarketData marketData) { return(calc.presentValue(trade, ratesLookup.marketDataView(marketData), optionLookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates par spread across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the par spread, one entry per scenario </returns> public virtual DoubleScenarioArray parSpread(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.parSpread(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates current cash across one or more scenarios. /// <para> /// The sum of all cash flows paid on the valuation date. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the current cash, one entry per scenario </returns> public virtual CurrencyScenarioArray currentCash(ResolvedFraTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.currentCash(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates accrued interest across one or more scenarios. /// <para> /// The accrued interest since the last payment. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the accrued interest, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray accruedInterest(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.accruedInterest(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="fxLookup"> the lookup used to query the option market data </param> /// <param name="marketData"> the market data </param> /// <param name="method"> the pricing method </param> /// <returns> the present value, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray presentValue(ResolvedFxVanillaOptionTrade trade, RatesMarketDataLookup ratesLookup, FxOptionMarketDataLookup fxLookup, ScenarioMarketData marketData, FxVanillaOptionMethod method) { return(calc.presentValue(trade, ratesLookup.marketDataView(marketData), fxLookup.marketDataView(marketData), method)); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value across one or more scenarios. /// </summary> /// <param name="trade"> the trade </param> /// <param name="lookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray presentValue(ResolvedSwapTrade trade, RatesMarketDataLookup lookup, ScenarioMarketData marketData) { return(calc.presentValue(trade, lookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of present value to a one basis point shift in /// the market quotes used to calibrate the curves. /// The result is provided for each affected curve and currency, bucketed by curve node. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <param name="swaptionLookup"> the lookup used to query the swaption market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedCmsTrade trade, RatesMarketDataLookup ratesLookup, SwaptionMarketDataLookup swaptionLookup, ScenarioMarketData marketData) { return(calc.pv01RatesMarketQuoteBucketed(trade, ratesLookup.marketDataView(marketData), swaptionLookup.marketDataView(marketData))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of present value to a one basis point shift in /// the market quotes used to calibrate the curves. /// The result is provided for each affected curve and currency, bucketed by curve node. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="marketData"> the market data </param> /// <param name="fxLookup"> the lookup used to query the option market data </param> /// <param name="method"> the pricing method </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual ScenarioArray <CurrencyParameterSensitivities> pv01RatesMarketQuoteBucketed(ResolvedFxVanillaOptionTrade trade, RatesMarketDataLookup ratesLookup, FxOptionMarketDataLookup fxLookup, ScenarioMarketData marketData, FxVanillaOptionMethod method) { return(calc.pv01RatesMarketQuoteBucketed(trade, ratesLookup.marketDataView(marketData), fxLookup.marketDataView(marketData), method)); }
//------------------------------------------------------------------------- /// <summary> /// Calculates present value sensitivity across one or more scenarios. /// <para> /// This is the sensitivity of present value to a one basis point shift in the calibrated curves. /// The result is the sum of the sensitivities of all affected curves. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesLookup"> the lookup used to query the market data </param> /// <param name="capFloorLookup"> the lookup used to query the cap/floor market data </param> /// <param name="marketData"> the market data </param> /// <returns> the present value sensitivity, one entry per scenario </returns> public virtual MultiCurrencyScenarioArray pv01RatesCalibratedSum(ResolvedIborCapFloorTrade trade, RatesMarketDataLookup ratesLookup, IborCapFloorMarketDataLookup capFloorLookup, ScenarioMarketData marketData) { return(calc.pv01RatesCalibratedSum(trade, ratesLookup.marketDataView(marketData), capFloorLookup.marketDataView(marketData))); }