// 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));
}
