public virtual void specifySource()
{
ObservableSource testSource = ObservableSource.of("test");
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addValue(FxRateId.of(Currency.GBP, Currency.USD), FxRate.of(Currency.GBP, Currency.USD, 1.4d)).addValue(FxRateId.of(Currency.GBP, Currency.USD, testSource), FxRate.of(Currency.GBP, Currency.USD, 1.41d)).build();
ScenarioFxRateProvider defaultRateProvider = ScenarioFxRateProvider.of(marketData);
ScenarioFxRateProvider sourceRateProvider = ScenarioFxRateProvider.of(marketData, testSource);
assertThat(defaultRateProvider.fxRate(Currency.GBP, Currency.USD, 0)).isEqualTo(1.4d);
assertThat(sourceRateProvider.fxRate(Currency.GBP, Currency.USD, 0)).isEqualTo(1.41d);
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public ScenarioArray<?> convertedTo(com.opengamma.strata.basics.currency.Currency resultCurrency, ScenarioFxRateProvider fxRateProvider)
public ScenarioArray <object> convertedTo(Currency resultCurrency, ScenarioFxRateProvider fxRateProvider)
{
int scenarioCount = ScenarioCount;
if (fxRateProvider.ScenarioCount != scenarioCount)
{
throw new System.ArgumentException(Messages.format("Expected {} FX rates but received {}", scenarioCount, fxRateProvider.ScenarioCount));
}
ImmutableList <object> converted = zipWithIndex(values.stream()).map(tp => convert(resultCurrency, fxRateProvider, tp.First, tp.Second)).collect(toImmutableList());
return(DefaultScenarioArray.of(converted));
}
// convert value if possible
private object convert(Currency reportingCurrency, ScenarioFxRateProvider fxRateProvider, object @base, int index)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: if (super instanceof com.opengamma.strata.basics.currency.FxConvertible<?>)
if (@base is FxConvertible <object> )
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.basics.currency.FxConvertible<?> convertible = (com.opengamma.strata.basics.currency.FxConvertible<?>) super;
FxConvertible <object> convertible = (FxConvertible <object>)@base;
return(convertible.convertedTo(reportingCurrency, fxRateProvider.fxRateProvider(index)));
}
return(@base);
}
public CurrencyScenarioArray convertedTo(Currency reportingCurrency, ScenarioFxRateProvider fxRateProvider)
{
if (Currency.Equals(reportingCurrency))
{
return(this);
}
if (fxRateProvider.ScenarioCount != amounts.size())
{
throw new System.ArgumentException(Messages.format("Expected {} FX rates but received {}", amounts.size(), fxRateProvider.ScenarioCount));
}
DoubleArray convertedValues = amounts.Values.mapWithIndex((i, v) => v * fxRateProvider.fxRate(Currency, reportingCurrency, i));
return(of(reportingCurrency, convertedValues));
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public ScenarioArray<?> convertedTo(com.opengamma.strata.basics.currency.Currency reportingCurrency, ScenarioFxRateProvider fxRateProvider)
public ScenarioArray <object> convertedTo(Currency reportingCurrency, ScenarioFxRateProvider fxRateProvider)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: if (value instanceof com.opengamma.strata.basics.currency.FxConvertible<?>)
if (value is FxConvertible <object> )
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.basics.currency.FxConvertible<?> convertible = (com.opengamma.strata.basics.currency.FxConvertible<?>) value;
FxConvertible <object> convertible = (FxConvertible <object>)value;
if (fxRateProvider.ScenarioCount != scenarioCount)
{
throw new System.ArgumentException(Messages.format("Expected {} FX rates but received {}", scenarioCount, fxRateProvider.ScenarioCount));
}
ImmutableList <object> converted = IntStream.range(0, scenarioCount).mapToObj(i => convertible.convertedTo(reportingCurrency, fxRateProvider.fxRateProvider(i))).collect(toImmutableList());
return(DefaultScenarioArray.of(converted));
}
return(this);
}
//-------------------------------------------------------------------------
/// <summary>
/// Executes the task, performing calculations for the target using multiple sets of market data.
/// <para>
/// This invokes the function with the correct set of market data.
///
/// </para>
/// </summary>
/// <param name="marketData"> the market data used in the calculation </param>
/// <param name="refData"> the reference data </param>
/// <returns> results of the calculation, one for every scenario in the market data </returns>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public CalculationResults execute(com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData)
public CalculationResults execute(ScenarioMarketData marketData, ReferenceData refData)
{
// calculate the results
//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 = calculate(marketData, refData);
IDictionary <Measure, Result <object> > results = calculate(marketData, refData);
// get a suitable FX provider
ScenarioFxRateProvider fxProvider = parameters.findParameter(typeof(FxRateLookup)).map(lookup => LookupScenarioFxRateProvider.of(marketData, lookup)).orElse(ScenarioFxRateProvider.of(marketData));
// convert the results, using a normal loop for better stack traces
ImmutableList.Builder <CalculationResult> resultBuilder = ImmutableList.builder();
foreach (CalculationTaskCell cell in cells)
{
resultBuilder.add(cell.createResult(this, target, results, fxProvider, refData));
}
// return the result
return(CalculationResults.of(target, resultBuilder.build()));
}
//-------------------------------------------------------------------------
public CurrencyScenarioArray convertedTo(Currency reportingCurrency, ScenarioFxRateProvider fxRateProvider)
{
int size = ScenarioCount;
if (fxRateProvider.ScenarioCount != size)
{
throw new System.ArgumentException(Messages.format("Expected {} FX rates but received {}", size, fxRateProvider.ScenarioCount));
}
double[] singleCurrencyValues = new double[size];
foreach (KeyValuePair <Currency, DoubleArray> entry in amounts.Values.entrySet())
{
Currency currency = entry.Key;
DoubleArray currencyValues = entry.Value;
for (int i = 0; i < size; i++)
{
double convertedValue = currencyValues.get(i) * fxRateProvider.fxRate(currency, reportingCurrency, i);
singleCurrencyValues[i] += convertedValue;
}
}
return(CurrencyScenarioArray.of(reportingCurrency, DoubleArray.ofUnsafe(singleCurrencyValues)));
}
// converts the value
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private com.opengamma.strata.collect.result.Result<?> convertCurrency(CalculationTask task, com.opengamma.strata.data.scenario.ScenarioFxConvertible<?> value, com.opengamma.strata.data.scenario.ScenarioFxRateProvider fxProvider, com.opengamma.strata.basics.ReferenceData refData)
private Result <object> convertCurrency <T1>(CalculationTask task, ScenarioFxConvertible <T1> value, ScenarioFxRateProvider fxProvider, ReferenceData refData)
{
Currency resolvedReportingCurrency = reportingCurrency(task, refData);
try
{
return(Result.success(value.convertedTo(resolvedReportingCurrency, fxProvider)));
}
catch (Exception ex)
{
return(Result.failure(FailureReason.CURRENCY_CONVERSION, ex, "Failed to convert value '{}' to currency '{}'", value, resolvedReportingCurrency));
}
}
// converts the value, if appropriate
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private com.opengamma.strata.collect.result.Result<?> convertCurrencyIfNecessary(CalculationTask task, com.opengamma.strata.collect.result.Result<?> result, com.opengamma.strata.data.scenario.ScenarioFxRateProvider fxProvider, com.opengamma.strata.basics.ReferenceData refData)
private Result <object> convertCurrencyIfNecessary <T1>(CalculationTask task, Result <T1> result, ScenarioFxRateProvider fxProvider, ReferenceData refData)
{
// the result is only converted if it is a success and both the measure and value are convertible
if (measure.CurrencyConvertible && !reportingCurrency_Renamed.None && result.Success && result.Value is ScenarioFxConvertible)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioFxConvertible<?> convertible = (com.opengamma.strata.data.scenario.ScenarioFxConvertible<?>) result.getValue();
ScenarioFxConvertible <object> convertible = (ScenarioFxConvertible <object>)result.Value;
return(convertCurrency(task, convertible, fxProvider, refData));
}
return(result);
}
/// <summary>
/// Creates the result from the map of calculated measures.
/// <para>
/// This extracts the calculated measure and performs currency conversion if necessary.
///
/// </para>
/// </summary>
/// <param name="task"> the calculation task </param>
/// <param name="target"> the target of the calculation </param>
/// <param name="results"> the map of result by measure </param>
/// <param name="fxProvider"> the market data </param>
/// <param name="refData"> the reference data </param>
/// <returns> the calculation result </returns>
internal CalculationResult createResult <T1>(CalculationTask task, CalculationTarget target, IDictionary <T1> results, ScenarioFxRateProvider fxProvider, ReferenceData refData)
{
// caller expects that this method does not throw an exception
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> calculated = results.get(measure);
Result <object> calculated = results[measure];
if (calculated == null)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
calculated = Result.failure(FailureReason.CALCULATION_FAILED, "Measure '{}' was not calculated by the function for target type '{}'", measure, target.GetType().FullName);
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = convertCurrencyIfNecessary(task, calculated, fxProvider, refData);
Result <object> result = convertCurrencyIfNecessary(task, calculated, fxProvider, refData);
return(CalculationResult.of(rowIndex, columnIndex, result));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @BeforeClass public void setUp() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void setUp()
{
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addValue(FxRateId.of(Currency.GBP, Currency.USD), FxRate.of(Currency.GBP, Currency.USD, 1.4d)).build();
fxRateProvider = ScenarioFxRateProvider.of(marketData);
}
