// unit price for one scenario internal double unitPrice(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { // mark to model BlackBondFutureVolatilities normalVols = checkBlackVols(volatilities); return(tradePricer.price(trade, discountingProvider, normalVols)); }
//------------------------------------------------------------------------- // gets the settlement price private double settlementPrice(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider) { StandardId standardId = trade.Product.SecurityId.StandardId; QuoteId id = QuoteId.of(standardId, FieldName.SETTLEMENT_PRICE); return(discountingProvider.data(id) / 100); // convert market quote to value needed }
//------------------------------------------------------------------------- // gets the settlement price private double settlementPrice(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider) { StandardId standardId = trade.Product.SecurityId.StandardId; QuoteId id = QuoteId.of(standardId, FieldName.SETTLEMENT_PRICE); return(discountingProvider.data(id)); }
// present value for one scenario internal CurrencyAmount presentValue(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider) { // mark to model double settlementPrice = this.settlementPrice(trade, discountingProvider); return(tradePricer.presentValue(trade, discountingProvider, settlementPrice)); }
// present value for one scenario internal CurrencyAmount presentValue(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { // mark to model double settlementPrice = this.settlementPrice(trade, discountingProvider); BlackBondFutureVolatilities normalVols = checkBlackVols(volatilities); return(tradePricer.presentValue(trade, discountingProvider, normalVols, settlementPrice)); }
//------------------------------------------------------------------------- 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))); }
public virtual void test_pv01_calibrated() { ScenarioMarketData md = FixedCouponBondTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingFixedCouponBondTradePricer pricer = DiscountingFixedCouponBondTradePricer.DEFAULT; PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, provider); CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens); MultiCurrencyAmount expectedPv01Cal = pvParamSens.total().multipliedBy(1e-4); CurrencyParameterSensitivities expectedPv01CalBucketed = pvParamSens.multipliedBy(1e-4); assertEquals(FixedCouponBondTradeCalculations.DEFAULT.pv01CalibratedSum(RTRADE, LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal))); assertEquals(FixedCouponBondTradeCalculations.DEFAULT.pv01CalibratedBucketed(RTRADE, LOOKUP, md), ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed))); }
//------------------------------------------------------------------------- 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))); }
//------------------------------------------------------------------------- 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_pv01_quote() { ScenarioMarketData md = BillTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); PointSensitivities pvPointSens = PRICER.presentValueSensitivity(RTRADE, provider); CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens); CurrencyParameterSensitivities expectedPv01CalBucketed = MQ_CALC.sensitivity(pvParamSens, provider).multipliedBy(1e-4); MultiCurrencyAmount expectedPv01Cal = expectedPv01CalBucketed.total(); assertEquals(BillTradeCalculations.DEFAULT.pv01MarketQuoteSum(RTRADE, LOOKUP, md), MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal))); assertEquals(BillTradeCalculations.DEFAULT.pv01MarketQuoteBucketed(RTRADE, LOOKUP, md), ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed))); assertEquals(BillTradeCalculations.DEFAULT.pv01MarketQuoteSum(RTRADE, provider), expectedPv01Cal); assertEquals(BillTradeCalculations.DEFAULT.pv01MarketQuoteBucketed(RTRADE, provider), expectedPv01CalBucketed); }
//------------------------------------------------------------------------- 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); }
public virtual void test_pv01_quote() { ScenarioMarketData md = FixedCouponBondTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingFixedCouponBondTradePricer pricer = DiscountingFixedCouponBondTradePricer.DEFAULT; PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, provider); CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens); CurrencyParameterSensitivities expectedPv01CalBucketed = MQ_CALC.sensitivity(pvParamSens, provider).multipliedBy(1e-4); MultiCurrencyAmount expectedPv01Cal = expectedPv01CalBucketed.total(); MultiCurrencyScenarioArray sumComputed = FixedCouponBondTradeCalculations.DEFAULT.pv01MarketQuoteSum(RTRADE, LOOKUP, md); ScenarioArray <CurrencyParameterSensitivities> bucketedComputed = FixedCouponBondTradeCalculations.DEFAULT.pv01MarketQuoteBucketed(RTRADE, LOOKUP, md); assertEquals(sumComputed.ScenarioCount, 1); assertEquals(sumComputed.get(0).Currencies, ImmutableSet.of(GBP)); assertTrue(DoubleMath.fuzzyEquals(sumComputed.get(0).getAmount(GBP).Amount, expectedPv01Cal.getAmount(GBP).Amount, 1.0e-10)); assertEquals(bucketedComputed.ScenarioCount, 1); assertTrue(bucketedComputed.get(0).equalWithTolerance(expectedPv01CalBucketed, 1.0e-10)); }
public virtual void test_bondDiscountingProvider() { ImmutableMap <SecurityId, RepoGroup> repoSecurityGroups = ImmutableMap.of(SEC_A1, GROUP_REPO_X); ImmutableMap <LegalEntityId, RepoGroup> repoGroups = ImmutableMap.of(ISSUER_B, GROUP_REPO_X); ImmutableMap <Pair <RepoGroup, Currency>, CurveId> repoCurves = ImmutableMap.of(Pair.of(GROUP_REPO_X, USD), CURVE_ID_USD1); ImmutableMap <LegalEntityId, LegalEntityGroup> issuerGroups = ImmutableMap.of(ISSUER_A, GROUP_ISSUER_M); ImmutableMap <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves = ImmutableMap.of(Pair.of(GROUP_ISSUER_M, USD), CURVE_ID_USD3); LegalEntityDiscountingMarketDataLookup test = LegalEntityDiscountingMarketDataLookup.of(repoSecurityGroups, repoGroups, repoCurves, issuerGroups, issuerCurves); LocalDate valDate = date(2015, 6, 30); Curve repoCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_USD1.CurveName, ACT_360), 1d); Curve issuerCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_USD3.CurveName, ACT_360), 2d); MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(CURVE_ID_USD1, repoCurve, CURVE_ID_USD3, issuerCurve)); LegalEntityDiscountingProvider provider = test.discountingProvider(md); assertEquals(provider.ValuationDate, valDate); assertEquals(provider.findData(CURVE_ID_USD1.CurveName), repoCurve); assertEquals(provider.findData(CURVE_ID_USD3.CurveName), issuerCurve); assertEquals(provider.findData(CurveName.of("Rubbish")), null); // check repo RepoCurveDiscountFactors rcdf = provider.repoCurveDiscountFactors(SEC_A1, ISSUER_A, USD); SimpleDiscountFactors rdf = (SimpleDiscountFactors)rcdf.DiscountFactors; assertEquals(rdf.Curve.Name, repoCurve.Name); assertEquals(rcdf, provider.repoCurveDiscountFactors(SEC_B1, ISSUER_B, USD)); assertThrowsIllegalArg(() => provider.repoCurveDiscountFactors(SEC_A1, ISSUER_A, GBP)); assertThrowsIllegalArg(() => provider.repoCurveDiscountFactors(SEC_C1, ISSUER_C, USD)); // check issuer IssuerCurveDiscountFactors icdf = provider.issuerCurveDiscountFactors(ISSUER_A, USD); SimpleDiscountFactors idf = (SimpleDiscountFactors)icdf.DiscountFactors; assertEquals(idf.Curve.Name, issuerCurve.Name); assertThrowsIllegalArg(() => provider.issuerCurveDiscountFactors(ISSUER_A, GBP)); assertThrowsIllegalArg(() => provider.issuerCurveDiscountFactors(ISSUER_C, USD)); }
// currency exposure for one scenario internal MultiCurrencyAmount currencyExposure(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider) { return(tradePricer.currencyExposure(trade, ratesProvider, discountingProvider)); }
/// <summary> /// Calculates present value for a single set of market data. /// </summary> /// <param name="trade"> the trade </param> /// <param name="discountingProvider"> the market data </param> /// <param name="volatilities"> the volatilities </param> /// <returns> the present value </returns> public virtual CurrencyAmount presentValue(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { return(calc.presentValue(trade, discountingProvider, volatilities)); }
/// <summary> /// Calculates currency exposure for a single set of market data. /// <para> /// The currency risk, expressed as the equivalent amount in each currency. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="discountingProvider"> the market data </param> /// <param name="volatilities"> the volatilities </param> /// <returns> the currency exposure </returns> public virtual MultiCurrencyAmount currencyExposure(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { return(calc.currencyExposure(trade, discountingProvider, volatilities)); }
/// <summary> /// Calculates unit price for a single set of market data. /// <para> /// This is the price of a single unit of the security. /// /// <h4>Price</h4> /// Strata uses <i>decimal prices</i> for bond futures options in the trade model, pricers and market data. /// This is coherent with the pricing of <seealso cref="BondFuture"/>. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="discountingProvider"> the market data </param> /// <param name="volatilities"> the volatilities </param> /// <returns> the present value </returns> public virtual double unitPrice(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { return(calc.unitPrice(trade, discountingProvider, volatilities)); }
/// <summary> /// Calculates present value sensitivity for a single set of market data. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedBondFutureOptionTrade, LegalEntityDiscountingMarketDataLookup, BondFutureOptionMarketDataLookup, 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="discountingProvider"> the market data </param> /// <param name="volatilities"> the volatilities </param> /// <returns> the present value sensitivity </returns> public virtual CurrencyParameterSensitivities pv01CalibratedBucketed(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { return(calc.pv01CalibratedBucketed(trade, discountingProvider, volatilities)); }
/// <summary> /// Calculates present value sensitivity for a single set of market data. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedBondFutureOptionTrade, LegalEntityDiscountingMarketDataLookup, BondFutureOptionMarketDataLookup, 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="discountingProvider"> the market data </param> /// <param name="volatilities"> the volatilities </param> /// <returns> the present value sensitivity </returns> public virtual MultiCurrencyAmount pv01CalibratedSum(ResolvedBondFutureOptionTrade trade, LegalEntityDiscountingProvider discountingProvider, BondFutureVolatilities volatilities) { return(calc.pv01CalibratedSum(trade, discountingProvider, volatilities)); }
/// <summary> /// Calculates present value for a single set of market data. /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <returns> the present value </returns> public virtual CurrencyAmount presentValue(ResolvedBillTrade trade, LegalEntityDiscountingProvider ratesProvider) { return(calc.presentValue(trade, ratesProvider)); }
// market quote bucketed PV01 for one scenario internal CurrencyParameterSensitivities pv01MarketQuoteBucketed(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider ratesProvider) { PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider); CurrencyParameterSensitivities parameterSensitivity = ratesProvider.parameterSensitivity(pointSensitivity); return(MARKET_QUOTE_SENS.sensitivity(parameterSensitivity, ratesProvider).multipliedBy(ONE_BASIS_POINT)); }
// calibrated bucketed PV01 for one scenario internal CurrencyParameterSensitivities pv01CalibratedBucketed(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider) { PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, ratesProvider, discountingProvider); return(discountingProvider.parameterSensitivity(pointSensitivity).multipliedBy(ONE_BASIS_POINT)); }
/// <summary> /// Calculates current cash for a single set of market data. /// <para> /// The sum of all cash flows paid on the valuation date. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <returns> the current cash </returns> public virtual CurrencyAmount currentCash(ResolvedBillTrade trade, LegalEntityDiscountingProvider ratesProvider) { return(calc.currentCash(trade, ratesProvider)); }
// par spread for one scenario internal double parSpread(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider) { double settlementPrice = this.settlementPrice(trade, discountingProvider); return(tradePricer.parSpread(trade, discountingProvider, settlementPrice)); }
// calibrated sum PV01 for one scenario internal MultiCurrencyAmount pv01CalibratedSum(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider) { PointSensitivities pointSensitivity = tradePricer.presentValueSensitivity(trade, discountingProvider); return(discountingProvider.parameterSensitivity(pointSensitivity).total().multipliedBy(ONE_BASIS_POINT)); }
/// <summary> /// Calculates present value sensitivity for a single set of market data. /// <para> /// This is the sensitivity of /// <seealso cref="#presentValue(ResolvedBillTrade, LegalEntityDiscountingMarketDataLookup, 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="ratesProvider"> the market data </param> /// <returns> the present value sensitivity </returns> public virtual CurrencyParameterSensitivities pv01MarketQuoteBucketed(ResolvedBillTrade trade, LegalEntityDiscountingProvider ratesProvider) { return(calc.pv01MarketQuoteBucketed(trade, ratesProvider)); }
// currency exposure for one scenario internal MultiCurrencyAmount currencyExposure(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider) { double settlementPrice = this.settlementPrice(trade, discountingProvider); return(tradePricer.currencyExposure(trade, discountingProvider, settlementPrice)); }
// unit price for one scenario internal double unitPrice(ResolvedBondFutureTrade trade, LegalEntityDiscountingProvider discountingProvider) { // mark to model return(tradePricer.price(trade, discountingProvider)); }
// present value for one scenario internal CurrencyAmount presentValue(ResolvedCapitalIndexedBondTrade trade, RatesProvider ratesProvider, LegalEntityDiscountingProvider discountingProvider) { return(tradePricer.presentValue(trade, ratesProvider, discountingProvider)); }
/// <summary> /// Calculates currency exposure for a single set of market data. /// <para> /// The currency risk, expressed as the equivalent amount in each currency. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the market data </param> /// <returns> the currency exposure </returns> public virtual MultiCurrencyAmount currencyExposure(ResolvedBillTrade trade, LegalEntityDiscountingProvider ratesProvider) { return(calc.currencyExposure(trade, ratesProvider)); }