/// <summary>
/// Tests the combinedWith method when the other set of market data is not an instance of ImmutableScenarioMarketData
/// </summary>
public virtual void test_combinedWithDifferentImpl()
{
LocalDateDoubleTimeSeries timeSeries1 = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 1).put(date(2011, 3, 9), 2).put(date(2011, 3, 10), 3).build();
LocalDateDoubleTimeSeries timeSeries2 = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 10).put(date(2011, 3, 9), 20).put(date(2011, 3, 10), 30).build();
LocalDateDoubleTimeSeries timeSeries2a = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 1000).put(date(2011, 3, 9), 2000).put(date(2011, 3, 10), 3000).build();
LocalDateDoubleTimeSeries timeSeries3 = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 100).put(date(2011, 3, 9), 200).put(date(2011, 3, 10), 300).build();
MarketData marketData = ImmutableMarketData.builder(LocalDate.of(2011, 3, 8)).addTimeSeries(TEST_ID1, timeSeries1).addTimeSeries(TEST_ID2, timeSeries2).addValue(TEST_ID1, 1.1).addValue(TEST_ID2, 1.2).build();
RepeatedScenarioMarketData repeatedScenarioMarketData = RepeatedScenarioMarketData.of(3, marketData);
ImmutableScenarioMarketData immutableScenarioMarketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addTimeSeries(TEST_ID2, timeSeries2a).addTimeSeries(TEST_ID3, timeSeries3).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(2.0, 2.1, 2.2)).addBox(TEST_ID3, MarketDataBox.ofScenarioValues(3.0, 3.1, 3.2)).build();
ScenarioMarketData combinedData = immutableScenarioMarketData.combinedWith(repeatedScenarioMarketData);
assertThat(combinedData.ScenarioCount).isEqualTo(3);
assertThat(combinedData.getValue(TEST_ID1).getValue(0)).isEqualTo(1.1);
assertThat(combinedData.getValue(TEST_ID1).getValue(2)).isEqualTo(1.1);
assertThat(combinedData.getValue(TEST_ID1).getValue(3)).isEqualTo(1.1);
assertThat(combinedData.getValue(TEST_ID2)).isEqualTo(MarketDataBox.ofScenarioValues(2.0, 2.1, 2.2));
assertThat(combinedData.getValue(TEST_ID3)).isEqualTo(MarketDataBox.ofScenarioValues(3.0, 3.1, 3.2));
assertThat(combinedData.getTimeSeries(TEST_ID1)).isEqualTo(timeSeries1);
assertThat(combinedData.getTimeSeries(TEST_ID2)).isEqualTo(timeSeries2a);
assertThat(combinedData.getTimeSeries(TEST_ID3)).isEqualTo(timeSeries3);
}
public virtual void isSingleOrScenarioValue()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
assertThat(box.SingleValue).False;
assertThat(box.ScenarioValue).True;
}
public virtual void combineWithScenarioBoxWithWrongNumberOfScenarios()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
MarketDataBox <int> otherBox = MarketDataBox.ofScenarioValues(15, 16, 17, 18);
assertThrows(() => box.combineWith(otherBox, (v1, v2) => v1 + v2), typeof(System.ArgumentException), "Scenario values must have the same number of scenarios.*");
}
public virtual void map()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
MarketDataBox <int> result = box.map(v => v * 2);
assertThat(result).isEqualTo(MarketDataBox.ofScenarioValues(54, 56, 58));
}
public virtual void stream()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
IList <int> list = box.ToList();
assertThat(list).isEqualTo(ImmutableList.of(27, 28, 29));
}
public virtual void getScenarioValueFromOtherScenarioValue()
{
MarketDataBox <double> box = MarketDataBox.ofScenarioValues(9d, 9d, 9d);
TestMarketData marketData = new TestMarketData(box);
TestArrayKey key = new TestArrayKey();
TestDoubleArray array = marketData.getScenarioValue(key);
assertThat(array.values).isEqualTo(DoubleArray.of(9, 9, 9));
}
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 MarketDataBox <R> mapWithIndex <R>(int scenarioCount, ObjIntFunction <T, R> fn)
{
if (scenarioCount != ScenarioCount)
{
throw new System.ArgumentException(Messages.format("Scenario count {} does not equal the scenario count of the value {}", scenarioCount, ScenarioCount));
}
IList <R> perturbedValues = IntStream.range(0, scenarioCount).mapToObj(idx => fn.apply(getValue(idx), idx)).collect(toImmutableList());
return(MarketDataBox.ofScenarioValues(perturbedValues));
}
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 getValue()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
assertThat(box.getValue(0)).isEqualTo(27);
assertThat(box.getValue(1)).isEqualTo(28);
assertThat(box.getValue(2)).isEqualTo(29);
assertThrows(() => box.getValue(-1), typeof(System.ArgumentException), "Expected 0 <= 'scenarioIndex' < 3, but found -1");
assertThrows(() => box.getValue(3), typeof(System.ArgumentException), "Expected 0 <= 'scenarioIndex' < 3, but found 3");
}
/// <summary>
/// Tests that applying a function multiple times to the value creates a box of scenario values.
/// </summary>
public virtual void mapWithIndex()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
MarketDataBox <int> scenarioBox = box.mapWithIndex(3, (v, idx) => v + idx);
assertThat(scenarioBox.ScenarioValue).True;
assertThat(scenarioBox.ScenarioCount).isEqualTo(3);
assertThat(scenarioBox.getValue(0)).isEqualTo(27);
assertThat(scenarioBox.getValue(1)).isEqualTo(29);
assertThat(scenarioBox.getValue(2)).isEqualTo(31);
}
public virtual void combineWithScenarioBox()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
MarketDataBox <int> otherBox = MarketDataBox.ofScenarioValues(15, 16, 17);
MarketDataBox <int> resultBox = box.combineWith(otherBox, (v1, v2) => v1 + v2);
assertThat(resultBox.ScenarioValue).True;
assertThat(resultBox.ScenarioCount).isEqualTo(3);
assertThat(resultBox.getValue(0)).isEqualTo(42);
assertThat(resultBox.getValue(1)).isEqualTo(44);
assertThat(resultBox.getValue(2)).isEqualTo(46);
}
public virtual void test_none()
{
ScenarioPerturbation <double> test = ScenarioPerturbation.none();
assertEquals(test.ScenarioCount, 1);
MarketDataBox <double> box1 = MarketDataBox.ofScenarioValues(1d, 2d, 3d);
assertEquals(test.applyTo(box1, REF_DATA), box1);
MarketDataBox <double> box2 = MarketDataBox.ofSingleValue(1d);
assertEquals(test.applyTo(box2, REF_DATA), box2);
}
/// <summary>
/// Creates zoned date time.
/// <para>
/// If the scenario size of {@code dates} is greater than the size of {@code localTimes},
/// {@code defaultLocalTime} is used.
/// If {@code dates} is single value, {@code defaultLocalTime} is used.
///
/// </para>
/// </summary>
/// <param name="dates"> the local date </param>
/// <returns> the zoned date time </returns>
public MarketDataBox <ZonedDateTime> toZonedDateTime(MarketDataBox <LocalDate> dates)
{
if (dates.ScenarioValue)
{
int nScenarios = dates.ScenarioCount;
int nTimes = localTimes.size();
IList <ZonedDateTime> zonedDateTimes = IntStream.range(0, nScenarios).mapToObj(scenarioIndex => zonedDateTime(dates.getValue(scenarioIndex), nTimes, scenarioIndex)).collect(Collectors.toList());
return(MarketDataBox.ofScenarioValues(zonedDateTimes));
}
ZonedDateTime zonedDateTime = dates.SingleValue.atTime(defaultLocalTime).atZone(zoneId);
return(MarketDataBox.ofSingleValue(zonedDateTime));
}
public virtual void buildScenario()
{
FxRateMarketDataFunction function = new FxRateMarketDataFunction();
MarketDataBox <double> quoteBox = MarketDataBox.ofScenarioValues(1.1d, 1.2d, 1.3d);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(QUOTE_ID, quoteBox).build();
MarketDataBox <FxRate> rateBox = function.build(RATE_ID, config(), marketData, REF_DATA);
assertThat(rateBox.SingleValue).False;
assertThat(rateBox.ScenarioCount).isEqualTo(3);
assertThat(rateBox.getValue(0)).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.1d));
assertThat(rateBox.getValue(1)).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.2d));
assertThat(rateBox.getValue(2)).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.3d));
}
public virtual void test_addBadScenarioCount()
{
FxRateId eurGbpId = FxRateId.of(Currency.EUR, Currency.GBP);
FxRateId eurUsdId = FxRateId.of(Currency.EUR, Currency.USD);
FxRate eurGbpRate1 = FxRate.of(Currency.EUR, Currency.GBP, 0.8);
FxRate eurGbpRate2 = FxRate.of(Currency.EUR, Currency.GBP, 0.9);
FxRate eurGbpRate3 = FxRate.of(Currency.EUR, Currency.GBP, 0.95);
FxRate eurUsdRate1 = FxRate.of(Currency.EUR, Currency.USD, 1.1);
FxRate eurUsdRate2 = FxRate.of(Currency.EUR, Currency.USD, 1.2);
ImmutableScenarioMarketDataBuilder builder = ImmutableScenarioMarketData.builder(VAL_DATE).addBox(eurGbpId, MarketDataBox.ofScenarioValues(eurGbpRate1, eurGbpRate2, eurGbpRate3));
assertThrowsIllegalArg(() => builder.addBox(eurUsdId, MarketDataBox.ofScenarioValues(eurUsdRate1, eurUsdRate2)));
}
public virtual void test_addSingleAndBox()
{
FxRateId eurGbpId = FxRateId.of(Currency.EUR, Currency.GBP);
FxRateId eurUsdId = FxRateId.of(Currency.EUR, Currency.USD);
FxRate eurGbpRate = FxRate.of(Currency.EUR, Currency.GBP, 0.8);
FxRate eurUsdRate1 = FxRate.of(Currency.EUR, Currency.USD, 1.1);
FxRate eurUsdRate2 = FxRate.of(Currency.EUR, Currency.USD, 1.2);
ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValue(eurGbpId, eurGbpRate).addBox(eurUsdId, MarketDataBox.ofScenarioValues(eurUsdRate1, eurUsdRate2)).build();
assertEquals(marketData.ScenarioCount, 2);
assertEquals(marketData.Ids, ImmutableSet.of(eurGbpId, eurUsdId));
assertEquals(marketData.getValue(eurGbpId), MarketDataBox.ofSingleValue(eurGbpRate));
assertEquals(marketData.getValue(eurUsdId), MarketDataBox.ofScenarioValues(eurUsdRate1, eurUsdRate2));
}
public virtual MarketDataBox <FxOptionVolatilities> build(FxOptionVolatilitiesId id, MarketDataConfig marketDataConfig, ScenarioMarketData marketData, ReferenceData refData)
{
FxOptionVolatilitiesDefinition volatilitiesDefinition = marketDataConfig.get(typeof(FxOptionVolatilitiesDefinition), id.Name.Name);
ValuationZoneTimeDefinition zoneTimeDefinition = marketDataConfig.get(typeof(ValuationZoneTimeDefinition));
int nScenarios = marketData.ScenarioCount;
MarketDataBox <LocalDate> valuationDates = marketData.ValuationDate;
MarketDataBox <ZonedDateTime> valuationDateTimes = zoneTimeDefinition.toZonedDateTime(valuationDates);
int nParameters = volatilitiesDefinition.ParameterCount;
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
ImmutableList <MarketDataBox <double> > inputs = volatilitiesDefinition.volatilitiesInputs().Select(q => marketData.getValue(q)).collect(toImmutableList());
ImmutableList <FxOptionVolatilities> vols = IntStream.range(0, nScenarios).mapToObj(scenarioIndex => volatilitiesDefinition.volatilities(valuationDateTimes.getValue(scenarioIndex), DoubleArray.of(nParameters, paramIndex => inputs.get(paramIndex).getValue(scenarioIndex)), refData)).collect(toImmutableList());
return(nScenarios > 1 ? MarketDataBox.ofScenarioValues(vols) : MarketDataBox.ofSingleValue(vols.get(0)));
}
public MarketDataBox <RatesCurveInputs> build(RatesCurveInputsId id, MarketDataConfig marketDataConfig, ScenarioMarketData marketData, ReferenceData refData)
{
CurveGroupName groupName = id.CurveGroupName;
CurveName curveName = id.CurveName;
RatesCurveGroupDefinition groupDefn = marketDataConfig.get(typeof(RatesCurveGroupDefinition), groupName);
Optional <CurveDefinition> optionalDefinition = groupDefn.findCurveDefinition(id.CurveName);
if (!optionalDefinition.Present)
{
throw new System.ArgumentException(Messages.format("No curve named '{}' found in group '{}'", curveName, groupName));
}
CurveDefinition configuredDefn = optionalDefinition.get();
// determine market data needs
MarketDataBox <LocalDate> valuationDates = marketData.ValuationDate;
bool multipleValuationDates = valuationDates.ScenarioValue;
// curve definition can vary for each valuation date
if (multipleValuationDates)
{
IList <CurveDefinition> curveDefns = IntStream.range(0, valuationDates.ScenarioCount).mapToObj(valuationDates.getValue).map((LocalDate valDate) => configuredDefn.filtered(valDate, refData)).collect(toImmutableList());
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(curveDefns);
ISet <MarketDataId <object> > requirements = nodeRequirements(curveDefns);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k)));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k)));
return(buildMultipleCurveInputs(MarketDataBox.ofScenarioValues(curveDefns), marketDataValues, valuationDates, refData));
}
// only one valuation date
LocalDate valuationDate = valuationDates.getValue(0);
CurveDefinition filteredDefn = configuredDefn.filtered(valuationDate, refData);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(com.google.common.collect.ImmutableList.of(filteredDefn));
ISet <MarketDataId <object> > requirements = nodeRequirements(ImmutableList.of(filteredDefn));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k)));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k)));
// Do any of the inputs contain values for multiple scenarios, or do they contain 1 value each?
bool multipleInputValues = marketDataValues.Values.Any(MarketDataBox.isScenarioValue);
return(multipleInputValues || multipleValuationDates?buildMultipleCurveInputs(MarketDataBox.ofSingleValue(filteredDefn), marketDataValues, valuationDates, refData) : buildSingleCurveInputs(filteredDefn, marketDataValues, valuationDate, refData));
}
// calibrates when there are multiple groups
private MarketDataBox <RatesCurveGroup> buildMultipleCurveGroups(RatesCurveGroupDefinition configuredGroup, RatesCurveCalibrator calibrator, MarketDataBox <LocalDate> valuationDateBox, IList <MarketDataBox <RatesCurveInputs> > inputBoxes, IDictionary <ObservableId, LocalDateDoubleTimeSeries> fixings, ReferenceData refData)
{
int scenarioCount = RatesCurveGroupMarketDataFunction.scenarioCount(valuationDateBox, inputBoxes);
ImmutableList.Builder <RatesCurveGroup> builder = ImmutableList.builder();
for (int i = 0; i < scenarioCount; i++)
{
LocalDate valuationDate = valuationDateBox.getValue(i);
RatesCurveGroupDefinition filteredGroup = configuredGroup.filtered(valuationDate, refData);
IList <RatesCurveInputs> curveInputsList = inputsForScenario(inputBoxes, i);
MarketData inputs = inputsByKey(valuationDate, curveInputsList, fixings);
builder.add(buildGroup(filteredGroup, calibrator, inputs, refData));
}
ImmutableList <RatesCurveGroup> curveGroups = builder.build();
return(MarketDataBox.ofScenarioValues(curveGroups));
}
// one valuation date, scenario market data
private MarketDataBox <RatesCurveInputs> buildMultipleCurveInputs <T1>(MarketDataBox <CurveDefinition> filteredDefns, IDictionary <T1> marketData, MarketDataBox <LocalDate> valuationDates, ReferenceData refData) where T1 : com.opengamma.strata.data.MarketDataId <T1>
{
// If there are multiple values for any of the input data values or for the valuation
// dates then we need to create multiple sets of inputs
int scenarioCount = RatesCurveInputsMarketDataFunction.scenarioCount(valuationDates, marketData);
ImmutableList.Builder <CurveMetadata> curveMetadataBuilder = ImmutableList.builder();
for (int i = 0; i < scenarioCount; i++)
{
LocalDate valDate = valuationDates.getValue(i);
CurveDefinition defn = filteredDefns.getValue(i);
curveMetadataBuilder.add(defn.metadata(valDate, refData));
}
IList <CurveMetadata> curveMetadata = curveMetadataBuilder.build();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<java.util.Map<? extends com.opengamma.strata.data.MarketDataId<?>, ?>> scenarioValues = java.util.stream.IntStream.range(0, scenarioCount).mapToObj(i -> buildScenarioValues(marketData, i)).collect(toImmutableList());
IList <IDictionary <MarketDataId <object>, ?> > scenarioValues = IntStream.range(0, scenarioCount).mapToObj(i => buildScenarioValues(marketData, i)).collect(toImmutableList());
IList <RatesCurveInputs> curveInputs = zip(scenarioValues.stream(), curveMetadata.stream()).map(pair => RatesCurveInputs.of(pair.First, pair.Second)).collect(toImmutableList());
return(MarketDataBox.ofScenarioValues(curveInputs));
}
private MarketDataBox <R> applyToScenarios <R>(System.Func <int, R> fn)
{
IList <R> results = IntStream.range(0, value.ScenarioCount).mapToObj(fn.apply).collect(toImmutableList());
return(MarketDataBox.ofScenarioValues(results));
}
public MarketDataBox <R> mapWithIndex <R>(int scenarioCount, ObjIntFunction <T, R> fn)
{
IList <R> perturbedValues = IntStream.range(0, scenarioCount).mapToObj(idx => fn.apply(value, idx)).collect(toImmutableList());
return(MarketDataBox.ofScenarioValues(perturbedValues));
}
public virtual void test_combinedWithOtherHasOneScenario()
{
ImmutableScenarioMarketData marketData1 = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(1.0, 1.1)).build();
ImmutableScenarioMarketData marketData2 = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(TEST_ID1, MarketDataBox.ofSingleValue(1.0)).build();
ImmutableScenarioMarketData expected = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(TEST_ID1, MarketDataBox.ofSingleValue(1.0)).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(1.0, 1.1)).build();
ScenarioMarketData combined = marketData1.combinedWith(marketData2);
assertThat(combined).isEqualTo(expected);
assertThat(combined.Ids).isEqualTo(ImmutableSet.of(TEST_ID1, TEST_ID2));
}
public virtual void test_combinedWithIncompatibleScenarioCount()
{
ImmutableScenarioMarketData marketData1 = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(TEST_ID1, MarketDataBox.ofScenarioValues(1.0, 1.1, 1.2)).build();
ImmutableScenarioMarketData marketData2 = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(1.0, 1.1)).build();
assertThrowsIllegalArg(() => marketData1.combinedWith(marketData2), ".* same number of scenarios .* 3 and 2");
}
public virtual void test_combinedWith()
{
LocalDateDoubleTimeSeries timeSeries1 = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 1).put(date(2011, 3, 9), 2).put(date(2011, 3, 10), 3).build();
LocalDateDoubleTimeSeries timeSeries2 = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 10).put(date(2011, 3, 9), 20).put(date(2011, 3, 10), 30).build();
LocalDateDoubleTimeSeries timeSeries2a = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 1000).put(date(2011, 3, 9), 2000).put(date(2011, 3, 10), 3000).build();
LocalDateDoubleTimeSeries timeSeries3 = LocalDateDoubleTimeSeries.builder().put(date(2011, 3, 8), 100).put(date(2011, 3, 9), 200).put(date(2011, 3, 10), 300).build();
ImmutableScenarioMarketData marketData1 = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addTimeSeries(TEST_ID1, timeSeries1).addTimeSeries(TEST_ID2, timeSeries2).addBox(TEST_ID1, MarketDataBox.ofScenarioValues(1.0, 1.1, 1.2)).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(2.0, 2.1, 2.2)).build();
ImmutableScenarioMarketData marketData2 = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 10)).addTimeSeries(TEST_ID2, timeSeries2a).addTimeSeries(TEST_ID3, timeSeries3).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(21.0, 21.1, 21.2)).addBox(TEST_ID3, MarketDataBox.ofScenarioValues(3.0, 3.1, 3.2)).build();
// marketData1 values should be in the combined data when the same ID is present in both
ImmutableScenarioMarketData expected = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addTimeSeries(TEST_ID1, timeSeries1).addTimeSeries(TEST_ID2, timeSeries2).addTimeSeries(TEST_ID3, timeSeries3).addBox(TEST_ID1, MarketDataBox.ofScenarioValues(1.0, 1.1, 1.2)).addBox(TEST_ID2, MarketDataBox.ofScenarioValues(2.0, 2.1, 2.2)).addBox(TEST_ID3, MarketDataBox.ofScenarioValues(3.0, 3.1, 3.2)).build();
ScenarioMarketData combined = marketData1.combinedWith(marketData2);
assertThat(combined).isEqualTo(expected);
assertThat(combined.Ids).isEqualTo(ImmutableSet.of(TEST_ID1, TEST_ID2, TEST_ID3));
}
/// <summary>
/// Tests that an exception is thrown when trying to apply a function multiple times with a scenario count
/// that doesn't match the scenario count of the box.
/// </summary>
public virtual void mapWithIndexWrongNumberOfScenarios()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
assertThrows(() => box.mapWithIndex(4, (v, idx) => v + idx), typeof(System.ArgumentException));
}
public virtual void getMarketDataType()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
assertThat(box.MarketDataType).isEqualTo(typeof(Integer));
}
public virtual void getScenarioCount()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
assertThat(box.ScenarioCount).isEqualTo(3);
}
public virtual void getSingleValue()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
assertThrows(box.getSingleValue, typeof(System.InvalidOperationException), "This box does not contain a single value");
}