public virtual void test_simpleMeasures()
{
FraTradeCalculationFunction function = new FraTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider();
DiscountingFraTradePricer pricer = DiscountingFraTradePricer.DEFAULT;
CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider);
ExplainMap expectedExplainPv = pricer.explainPresentValue(RTRADE, provider);
double expectedParRate = pricer.parRate(RTRADE, provider);
double expectedParSpread = pricer.parSpread(RTRADE, provider);
CashFlows expectedCashFlows = pricer.cashFlows(RTRADE, provider);
MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider);
CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, provider);
ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.EXPLAIN_PRESENT_VALUE, Measures.PAR_RATE, Measures.PAR_SPREAD, Measures.CASH_FLOWS, Measures.CURRENCY_EXPOSURE, Measures.CURRENT_CASH, Measures.RESOLVED_TARGET);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.EXPLAIN_PRESENT_VALUE, Result.success(ScenarioArray.of(ImmutableList.of(expectedExplainPv)))).containsEntry(Measures.PAR_RATE, Result.success(DoubleScenarioArray.of(ImmutableList.of(expectedParRate)))).containsEntry(Measures.PAR_SPREAD, Result.success(DoubleScenarioArray.of(ImmutableList.of(expectedParSpread)))).containsEntry(Measures.CASH_FLOWS, Result.success(ScenarioArray.of(ImmutableList.of(expectedCashFlows)))).containsEntry(Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure)))).containsEntry(Measures.CURRENT_CASH, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RTRADE));
}
public RatesMarketData scenario(int scenarioIndex)
{
RatesMarketData current = cache.get(scenarioIndex);
if (current != null)
{
return(current);
}
return(cache.updateAndGet(scenarioIndex, v => v != null ? v : lookup.marketDataView(marketData.scenario(scenarioIndex))));
}
public virtual void test_fxProvider()
{
RatesMarketDataLookup test = RatesMarketDataLookup.of(ImmutableMap.of(), ImmutableMap.of());
LocalDate valDate = date(2015, 6, 30);
FxRateId gbpUsdId = FxRateId.of(GBP, USD);
FxRate gbpUsdRate = FxRate.of(GBP, USD, 1.6);
MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(gbpUsdId, gbpUsdRate));
FxRateProvider fxProvider = test.fxRateProvider(md);
assertEquals(fxProvider.fxRate(GBP, USD), 1.6);
assertEquals(test.marketDataView(md).fxRateProvider().fxRate(GBP, USD), 1.6);
assertThrows(() => fxProvider.fxRate(EUR, USD), typeof(MarketDataNotFoundException));
}
//-------------------------------------------------------------------------
public virtual void test_marketDataView()
{
ImmutableMap <Currency, CurveId> discounts = ImmutableMap.of(USD, CURVE_ID_DSC);
ImmutableMap <Index, CurveId> forwards = ImmutableMap.of(USD_LIBOR_3M, CURVE_ID_FWD);
RatesMarketDataLookup test = RatesMarketDataLookup.of(discounts, forwards);
LocalDate valDate = date(2015, 6, 30);
ScenarioMarketData md = new TestMarketDataMap(valDate, ImmutableMap.of(), ImmutableMap.of());
RatesScenarioMarketData multiScenario = test.marketDataView(md);
assertEquals(multiScenario.Lookup, test);
assertEquals(multiScenario.MarketData, md);
assertEquals(multiScenario.ScenarioCount, 1);
RatesMarketData scenario = multiScenario.scenario(0);
assertEquals(scenario.Lookup, test);
assertEquals(scenario.MarketData, md.scenario(0));
assertEquals(scenario.ValuationDate, valDate);
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.product.cms.CmsTrade trade, java.util.Set<com.opengamma.strata.calc.Measure> measures, com.opengamma.strata.calc.runner.CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData scenarioMarketData, com.opengamma.strata.basics.ReferenceData refData)
public virtual IDictionary <Measure, Result <object> > calculate(CmsTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData)
{
// expand the trade once for all measures and all scenarios
ResolvedCmsTrade resolved = trade.resolve(refData);
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
RatesScenarioMarketData ratesMarketData = ratesLookup.marketDataView(scenarioMarketData);
SwaptionMarketDataLookup swaptionLookup = parameters.getParameter(typeof(SwaptionMarketDataLookup));
SwaptionScenarioMarketData swaptionMarketData = swaptionLookup.marketDataView(scenarioMarketData);
CmsSabrExtrapolationParams cmsParams = parameters.getParameter(typeof(CmsSabrExtrapolationParams));
CmsMeasureCalculations calculations = new CmsMeasureCalculations(cmsParams);
// loop around measures, calculating all scenarios for one measure
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = new java.util.HashMap<>();
IDictionary <Measure, Result <object> > results = new Dictionary <Measure, Result <object> >();
foreach (Measure measure in measures)
{
results[measure] = calculate(measure, resolved, calculations, ratesMarketData, swaptionMarketData);
}
return(results);
}
