public virtual void test_ofSingleValue()
{
ScenarioArray <string> test = ScenarioArray.ofSingleValue(3, "aaa");
SingleScenarioArray <string> expected = SingleScenarioArray.of(3, "aaa");
assertEquals(test, expected);
}
public virtual void test_of_list()
{
ScenarioArray <string> test = ScenarioArray.of(ImmutableList.of("1", "2", "3"));
DefaultScenarioArray <string> expected = DefaultScenarioArray.of("1", "2", "3");
assertEquals(test, expected);
}
public virtual void test_of_function()
{
ScenarioArray <string> test = ScenarioArray.of(3, i => Convert.ToString(i + 1));
DefaultScenarioArray <string> expected = DefaultScenarioArray.of("1", "2", "3");
assertEquals(test, expected);
}
/// <summary>
/// Test that ScenarioArrays containing a single value are unwrapped when calling calculateAsync().
/// </summary>
public virtual void unwrapScenarioResultsAsync()
{
ScenarioArray <string> scenarioResult = ScenarioArray.of("foo");
ScenarioResultFunction fn = new ScenarioResultFunction(TestingMeasures.PRESENT_VALUE, scenarioResult);
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
Column column = Column.of(TestingMeasures.PRESENT_VALUE);
CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column));
// using the direct executor means there is no need to close/shutdown the runner
CalculationTaskRunner test = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService());
Listener listener = new Listener();
MarketData marketData = MarketData.empty(VAL_DATE);
test.calculateAsync(tasks, marketData, REF_DATA, listener);
CalculationResult calculationResult1 = listener.result;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result1 = calculationResult1.getResult();
Result <object> result1 = calculationResult1.Result;
// Check the result contains the string directly, not the result wrapping the string
assertThat(result1).hasValue("foo");
test.calculateMultiScenarioAsync(tasks, ScenarioMarketData.of(1, marketData), REF_DATA, listener);
CalculationResult calculationResult2 = listener.result;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result2 = calculationResult2.getResult();
Result <object> result2 = calculationResult2.Result;
// Check the result contains the scenario result wrapping the string
assertThat(result2).hasValue(scenarioResult);
}
public virtual void test_of_array()
{
ScenarioArray <string> test = ScenarioArray.of("1", "2", "3");
DefaultScenarioArray <string> expected = DefaultScenarioArray.of("1", "2", "3");
assertEquals(test, expected);
}
private MarketDataBox <R> combineWithMultiple <U, R>(MarketDataBox <U> other, System.Func <T, U, R> fn)
{
ScenarioArray <U> otherValue = other.ScenarioValue;
int scenarioCount = otherValue.ScenarioCount;
IList <R> values = IntStream.range(0, scenarioCount).mapToObj(i => fn(value, other.getValue(i))).collect(toImmutableList());
return(MarketDataBox.ofScenarioValues(values));
}
public virtual void getScenarioValue()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
ScenarioArray <int> scenarioValue = box.ScenarioValue;
assertThat(scenarioValue.ScenarioCount).isEqualTo(3);
assertThat(scenarioValue.get(0)).isEqualTo(27);
assertThat(scenarioValue.get(1)).isEqualTo(28);
assertThat(scenarioValue.get(2)).isEqualTo(29);
}
public virtual void toScenarioArray2()
{
IList <MultiCurrencyAmount> amounts = ImmutableList.of(MultiCurrencyAmount.of(Currency.GBP, 1), MultiCurrencyAmount.of(CurrencyAmount.of(Currency.USD, 2), CurrencyAmount.of(Currency.GBP, 3)));
ScenarioArray <MultiCurrencyAmount> expectedResult = ScenarioArray.of(amounts);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
ScenarioArray <MultiCurrencyAmount> result = amounts.collect(FunctionUtils.toScenarioArray());
assertThat(result).isEqualTo(expectedResult);
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trade that will have measures calculated
IList <Trade> trades = ImmutableList.of(createVanillaFixedVsLibor3mSwap());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM));
// use the built-in example market data
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder();
// the complete set of rules for calculating measures
LocalDate valuationDate = LocalDate.of(2014, 1, 22);
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions, Currency.USD, marketDataBuilder.ratesLookup(valuationDate));
// mappings that select which market data to apply perturbations to
// this applies the perturbations above to all curves
PerturbationMapping <Curve> mapping = PerturbationMapping.of(MarketDataFilter.ofIdType(typeof(CurveId)), CurveParallelShifts.absolute(0, ONE_BP));
// create a scenario definition containing the single mapping above
// this creates two scenarios - one for each perturbation in the mapping
ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(mapping);
// build a market data snapshot for the valuation date
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, scenarioDefinition);
Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData);
// TODO Replace the results processing below with a report once the reporting framework supports scenarios
// The results are lists of currency amounts containing one value for each scenario
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pvList = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue();
ScenarioArray <object> pvList = (ScenarioArray <object>)results.get(0, 0).Value;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pv01List = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 1).getValue();
ScenarioArray <object> pv01List = (ScenarioArray <object>)results.get(0, 1).Value;
double pvBase = ((CurrencyAmount)pvList.get(0)).Amount;
double pvShifted = ((CurrencyAmount)pvList.get(1)).Amount;
double pv01Base = ((CurrencyAmount)pv01List.get(0)).Amount;
NumberFormat numberFormat = new DecimalFormat("###,##0.00", new DecimalFormatSymbols(Locale.ENGLISH));
Console.WriteLine(" PV (base) = " + numberFormat.format(pvBase));
Console.WriteLine(" PV (1 bp curve shift) = " + numberFormat.format(pvShifted));
Console.WriteLine("PV01 (algorithmic differentiation) = " + numberFormat.format(pv01Base));
Console.WriteLine(" PV01 (finite difference) = " + numberFormat.format(pvShifted - pvBase));
}
private MarketDataBox <R> combineWithMultiple <R, U>(MarketDataBox <U> other, System.Func <T, U, R> fn)
{
ScenarioArray <U> otherValue = other.ScenarioValue;
if (otherValue.ScenarioCount != value.ScenarioCount)
{
string message = Messages.format("Scenario values must have the same number of scenarios. {} has {} scenarios, {} has {}", value, value.ScenarioCount, otherValue, otherValue.ScenarioCount);
throw new System.ArgumentException(message);
}
return(applyToScenarios(i => fn(value.get(i), otherValue.get(i))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public Builder<T> set(String propertyName, Object newValue)
public override Builder <T> set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 111972721: // value
this.value_Renamed = (ScenarioArray <T>)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
public virtual void notConvertible()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
IList <string> values = ImmutableList.of("a", "b", "c");
DefaultScenarioArray <string> test = DefaultScenarioArray.of(values);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ScenarioArray<?> convertedList = test.convertedTo(com.opengamma.strata.basics.currency.Currency.GBP, fxProvider);
ScenarioArray <object> convertedList = test.convertedTo(Currency.GBP, fxProvider);
assertThat(convertedList).isEqualTo(test);
}
public virtual void convertCurrencyAmount()
{
FxRateScenarioArray rates = FxRateScenarioArray.of(GBP, USD, DoubleArray.of(1.61, 1.62, 1.63));
ScenarioFxRateProvider fxProvider = new TestScenarioFxRateProvider(rates);
SingleScenarioArray <CurrencyAmount> test = SingleScenarioArray.of(3, CurrencyAmount.of(GBP, 2));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ScenarioArray<?> convertedList = test.convertedTo(USD, fxProvider);
ScenarioArray <object> convertedList = test.convertedTo(USD, fxProvider);
IList <CurrencyAmount> expectedValues = ImmutableList.of(CurrencyAmount.of(USD, 2 * 1.61), CurrencyAmount.of(USD, 2 * 1.62), CurrencyAmount.of(USD, 2 * 1.63));
DefaultScenarioArray <CurrencyAmount> expectedList = DefaultScenarioArray.of(expectedValues);
assertThat(convertedList).isEqualTo(expectedList);
}
/// <summary>
/// Test the result is returned unchanged if using ReportingCurrency.NONE.
/// </summary>
public virtual void convertResultCurrencyNoConversionRequested()
{
SupplierFunction <CurrencyAmount> fn = SupplierFunction.of(() => CurrencyAmount.of(EUR, 1d));
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, ReportingCurrency.NONE);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).build();
CalculationResults calculationResults = task.execute(marketData, REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult();
Result <object> result = calculationResults.Cells.get(0).Result;
assertThat(result).hasValue(ScenarioArray.of(CurrencyAmount.of(EUR, 1d)));
}
/// <summary>
/// Tests that executing a function that returns a success result returns the underlying result without wrapping it.
/// </summary>
public virtual void executeSuccessResultValue()
{
SupplierFunction <Result <ScenarioArray <string> > > fn = SupplierFunction.of(() => Result.success(ScenarioArray.of("foo")));
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).build();
CalculationResults calculationResults = task.execute(marketData, REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult();
Result <object> result = calculationResults.Cells.get(0).Result;
assertThat(result).hasValue(ScenarioArray.of("foo"));
}
/// <summary>
/// Test a non-convertible result is returned even if there is no reporting currency.
/// </summary>
public virtual void nonConvertibleResultReturnedWhenNoReportingCurrency()
{
TestFunction fn = new TestFunction();
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).build();
CalculationResults calculationResults = task.execute(marketData, REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult();
Result <object> result = calculationResults.Cells.get(0).Result;
assertThat(result).hasValue(ScenarioArray.of("bar"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(TestTarget target, java.util.Set<com.opengamma.strata.calc.Measure> measures, CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData)
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
public IDictionary <Measure, Result <object> > calculate(TestTarget target, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData marketData, ReferenceData refData)
{
T obj = supplier.get();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: if (obj instanceof com.opengamma.strata.collect.result.Result<?>)
if (obj is Result <object> )
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: return com.google.common.collect.ImmutableMap.of(com.opengamma.strata.calc.TestingMeasures.PRESENT_VALUE, (com.opengamma.strata.collect.result.Result<?>) obj);
return(ImmutableMap.of(TestingMeasures.PRESENT_VALUE, (Result <object>)obj));
}
ScenarioArray <object> array = ScenarioArray.of(obj);
return(ImmutableMap.of(TestingMeasures.PRESENT_VALUE, Result.success(array)));
}
private static void outputPnl <T1>(IList <LocalDate> scenarioDates, ScenarioArray <T1> scenarioValuations)
{
NumberFormat numberFormat = new DecimalFormat("0.00", new DecimalFormatSymbols(Locale.ENGLISH));
double basePv = ((CurrencyAmount)scenarioValuations.get(0)).Amount;
Console.WriteLine("Base PV (USD): " + numberFormat.format(basePv));
Console.WriteLine();
Console.WriteLine("P&L series (USD):");
for (int i = 1; i < scenarioValuations.ScenarioCount; i++)
{
double scenarioPv = ((CurrencyAmount)scenarioValuations.get(i)).Amount;
double pnl = scenarioPv - basePv;
LocalDate scenarioDate = scenarioDates[i];
Console.WriteLine(Messages.format("{} = {}", scenarioDate, numberFormat.format(pnl)));
}
}
/// <summary>
/// Test that ScenarioArrays containing multiple values are an error.
/// </summary>
public virtual void unwrapMultipleScenarioResults()
{
ScenarioArray <string> scenarioResult = ScenarioArray.of("foo", "bar");
ScenarioResultFunction fn = new ScenarioResultFunction(TestingMeasures.PAR_RATE, scenarioResult);
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PAR_RATE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
Column column = Column.of(TestingMeasures.PAR_RATE);
CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column));
// using the direct executor means there is no need to close/shutdown the runner
CalculationTaskRunner test = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService());
MarketData marketData = MarketData.empty(VAL_DATE);
assertThrowsIllegalArg(() => test.calculate(tasks, marketData, REF_DATA));
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades for which to calculate a P&L series
IList <Trade> trades = ImmutableList.of(createTrade());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
// use the built-in example historical scenario market data
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketDataBuilder.ofResource(MARKET_DATA_RESOURCE_ROOT);
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions, marketDataBuilder.ratesLookup(LocalDate.of(2015, 4, 23)));
// load the historical calibrated curves from which we will build our scenarios
// these curves are provided in the example data environment
SortedDictionary <LocalDate, RatesCurveGroup> historicalCurves = marketDataBuilder.loadAllRatesCurves();
// sorted list of dates for the available series of curves
// the entries in the P&L vector we produce will correspond to these dates
IList <LocalDate> scenarioDates = new List <LocalDate>(historicalCurves.Keys);
// build the historical scenarios
ScenarioDefinition historicalScenarios = buildHistoricalScenarios(historicalCurves, scenarioDates);
// build a market data snapshot for the valuation date
// this is the base snapshot which will be perturbed by the scenarios
LocalDate valuationDate = LocalDate.of(2015, 4, 23);
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the reference data, such as holidays and securities
ReferenceData refData = ReferenceData.standard();
// calculate the results
MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData);
ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, historicalScenarios);
Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData);
// the results contain the one measure requested (Present Value) for each scenario
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> scenarioValuations = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue();
ScenarioArray <object> scenarioValuations = (ScenarioArray <object>)results.get(0, 0).Value;
outputPnl(scenarioDates, scenarioValuations);
}
//-------------------------------------------------------------------------
// Test that ScenarioArrays containing a single value are unwrapped.
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void unwrapScenarioResults() throws Exception
public virtual void unwrapScenarioResults()
{
ScenarioArray <string> scenarioResult = ScenarioArray.of("foo");
ScenarioResultFunction fn = new ScenarioResultFunction(TestingMeasures.PRESENT_VALUE, scenarioResult);
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
Column column = Column.of(TestingMeasures.PRESENT_VALUE);
CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column));
// using the direct executor means there is no need to close/shutdown the runner
CalculationTaskRunner test = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService());
MarketData marketData = MarketData.empty(VAL_DATE);
Results results1 = test.calculate(tasks, marketData, REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result1 = results1.get(0, 0);
Result <object> result1 = results1.get(0, 0);
// Check the result contains the string directly, not the result wrapping the string
assertThat(result1).hasValue("foo");
Results results2 = test.calculateMultiScenario(tasks, ScenarioMarketData.of(1, marketData), REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result2 = results2.get(0, 0);
Result <object> result2 = results2.get(0, 0);
// Check the result contains the scenario result wrapping the string
assertThat(result2).hasValue(scenarioResult);
ResultsListener resultsListener = new ResultsListener();
test.calculateAsync(tasks, marketData, REF_DATA, resultsListener);
CompletableFuture <Results> future = resultsListener.Future;
// The future is guaranteed to be done because everything is running on a single thread
assertThat(future.Done).True;
Results results3 = future.get();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result3 = results3.get(0, 0);
Result <object> result3 = results3.get(0, 0);
// Check the result contains the string directly, not the result wrapping the string
assertThat(result3).hasValue("foo");
}
//-------------------------------------------------------------------------
/// <summary>
/// Unwraps the result from an instance of <seealso cref="ScenarioArray"/> containing a single result.
/// <para>
/// When the user executes a single scenario the functions are invoked with a set of scenario market data
/// of size 1. This means the functions are simpler and always deal with scenarios. But if the user has
/// asked for a single set of results they don't want to see a collection of size 1 so the scenario results
/// need to be unwrapped.
/// </para>
/// <para>
/// If {@code result} is a failure or doesn't contain a {@code ScenarioArray} it is returned.
/// </para>
/// <para>
/// If this method is called with a {@code ScenarioArray} containing more than one value it throws an exception.
/// </para>
/// </summary>
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private static com.opengamma.strata.collect.result.Result<?> unwrapScenarioResult(com.opengamma.strata.collect.result.Result<?> result)
private static Result <object> unwrapScenarioResult <T1>(Result <T1> result)
{
if (result.Failure)
{
return(result);
}
object value = result.Value;
if (!(value is ScenarioArray))
{
return(result);
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> scenarioResult = (com.opengamma.strata.data.scenario.ScenarioArray<?>) value;
ScenarioArray <object> scenarioResult = (ScenarioArray <object>)value;
if (scenarioResult.ScenarioCount != 1)
{
throw new System.ArgumentException(Messages.format("Expected one result but found {} in {}", scenarioResult.ScenarioCount, scenarioResult));
}
return(Result.success(scenarioResult.get(0)));
}
public virtual void test_pv01_quote()
{
FixedCouponBondTradeCalculationFunction <FixedCouponBondTrade> function = FixedCouponBondTradeCalculationFunction.TRADE;
ScenarioMarketData md = 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();
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_MARKET_QUOTE_SUM, Measures.PV01_MARKET_QUOTE_BUCKETED);
//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<?>> computed = function.calculate(TRADE, measures, PARAMS, md, REF_DATA);
IDictionary <Measure, Result <object> > computed = function.calculate(TRADE, measures, PARAMS, md, REF_DATA);
MultiCurrencyScenarioArray sumComputed = (MultiCurrencyScenarioArray)computed[Measures.PV01_MARKET_QUOTE_SUM].Value;
ScenarioArray <CurrencyParameterSensitivities> bucketedComputed = (ScenarioArray <CurrencyParameterSensitivities>)computed[Measures.PV01_MARKET_QUOTE_BUCKETED].Value;
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));
}
//-------------------------------------------------------------------------
// calculates cash flows for all scenarios
internal ScenarioArray <CashFlows> cashFlows(ResolvedFraTrade trade, RatesScenarioMarketData marketData)
{
return(ScenarioArray.of(marketData.ScenarioCount, i => cashFlows(trade, marketData.scenario(i).ratesProvider())));
}
//-------------------------------------------------------------------------
// calculates explain present value for all scenarios
internal ScenarioArray <ExplainMap> explainPresentValue(ResolvedFraTrade trade, RatesScenarioMarketData marketData)
{
return(ScenarioArray.of(marketData.ScenarioCount, i => explainPresentValue(trade, marketData.scenario(i).ratesProvider())));
}
//-------------------------------------------------------------------------
// calculates single-node gamma PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01SingleNodeGammaBucketed(ResolvedFraTrade trade, RatesScenarioMarketData marketData)
{
return(ScenarioArray.of(marketData.ScenarioCount, i => pv01SingleNodeGammaBucketed(trade, marketData.scenario(i).ratesProvider())));
}
//-------------------------------------------------------------------------
// calculates semi-parallel gamma PV01 for all scenarios
internal ScenarioArray <CurrencyParameterSensitivities> pv01SemiParallelGammaBucketed(ResolvedFraTrade trade, RatesScenarioMarketData marketData)
{
return(ScenarioArray.of(marketData.ScenarioCount, i => pv01SemiParallelGammaBucketed(trade, marketData.scenario(i))));
}
public virtual void test_pv01()
{
CapitalIndexedBondTradeCalculationFunction <CapitalIndexedBondTrade> function = CapitalIndexedBondTradeCalculationFunction.TRADE;
ScenarioMarketData md = marketData();
RatesProvider ratesProvider = RATES_LOOKUP.marketDataView(md.scenario(0)).ratesProvider();
LegalEntityDiscountingProvider ledProvider = LED_LOOKUP.marketDataView(md.scenario(0)).discountingProvider();
DiscountingCapitalIndexedBondTradePricer pricer = DiscountingCapitalIndexedBondTradePricer.DEFAULT;
PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, ratesProvider, ledProvider);
CurrencyParameterSensitivities pvParamSens = ledProvider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01Cal = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedPv01CalBucketed = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed))));
}
public virtual void test_pv01()
{
TermDepositTradeCalculationFunction function = new TermDepositTradeCalculationFunction();
ScenarioMarketData md = marketData();
RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0));
DiscountingTermDepositProductPricer pricer = DiscountingTermDepositProductPricer.DEFAULT;
ResolvedTermDeposit resolved = TRADE.Product.resolve(REF_DATA);
PointSensitivities pvPointSens = pricer.presentValueSensitivity(resolved, provider);
CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens);
MultiCurrencyAmount expectedPv01 = pvParamSens.total().multipliedBy(1e-4);
CurrencyParameterSensitivities expectedBucketedPv01 = pvParamSens.multipliedBy(1e-4);
ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED);
assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedBucketedPv01))));
}
//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(TestTarget target, java.util.Set<com.opengamma.strata.calc.Measure> measures, CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData)
public IDictionary <Measure, Result <object> > calculate(TestTarget target, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData marketData, ReferenceData refData)
{
ScenarioArray <string> array = ScenarioArray.of("bar");
return(ImmutableMap.of(TestingMeasures.PRESENT_VALUE, Result.success(array)));
}