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