public virtual void map()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
MarketDataBox <int> result = box.map(v => v * 2);
assertThat(result).isEqualTo(MarketDataBox.ofSingleValue(54));
}
public virtual void isSingleOrScenarioValue()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
assertThat(box.SingleValue).True;
assertThat(box.ScenarioValue).False;
}
public virtual void test_of_repeated()
{
ScenarioMarketData test = ScenarioMarketData.of(1, MarketData.of(VAL_DATE, ImmutableMap.of(ID1, VAL1)));
assertThat(test.ValuationDate).isEqualTo(MarketDataBox.ofSingleValue(VAL_DATE));
assertThat(test.getValue(ID1)).isEqualTo(MarketDataBox.ofSingleValue(VAL1));
}
public virtual void relative()
{
IList <LabelDateParameterMetadata> nodeMetadata = ImmutableList.of(LabelDateParameterMetadata.of(date(2011, 3, 8), TNR_1M), LabelDateParameterMetadata.of(date(2011, 5, 8), TNR_3M), LabelDateParameterMetadata.of(date(2011, 8, 8), TNR_6M));
// This should create 4 scenarios. Scenario zero has no shifts and scenario 3 doesn't have shifts on all nodes
PointShifts shift = PointShifts.builder(ShiftType.RELATIVE).addShift(1, TNR_1W, 0.1).addShift(1, TNR_1M, 0.2).addShift(1, TNR_3M, 0.3).addShift(2, TNR_1M, 0.4).addShift(2, TNR_3M, 0.5).addShift(2, TNR_6M, 0.6).addShift(3, TNR_3M, 0.7).build();
Curve curve = InterpolatedNodalCurve.of(Curves.zeroRates(CurveName.of("curve"), DayCounts.ACT_365F, nodeMetadata), DoubleArray.of(1, 2, 3), DoubleArray.of(5, 6, 7), INTERPOLATOR);
MarketDataBox <ParameterizedData> shiftedCurveBox = shift.applyTo(MarketDataBox.ofSingleValue(curve), REF_DATA);
Curve scenario1Curve = InterpolatedNodalCurve.of(Curves.zeroRates(CurveName.of("curve"), DayCounts.ACT_365F, nodeMetadata), DoubleArray.of(1, 2, 3), DoubleArray.of(6, 7.8, 7), INTERPOLATOR);
Curve scenario2Curve = InterpolatedNodalCurve.of(Curves.zeroRates(CurveName.of("curve"), DayCounts.ACT_365F, nodeMetadata), DoubleArray.of(1, 2, 3), DoubleArray.of(7, 9, 11.2), INTERPOLATOR);
Curve scenario3Curve = InterpolatedNodalCurve.of(Curves.zeroRates(CurveName.of("curve"), DayCounts.ACT_365F, nodeMetadata), DoubleArray.of(1, 2, 3), DoubleArray.of(5, 10.2, 7), INTERPOLATOR);
// Scenario zero has no perturbations so the expected curve is the same as the input
IList <Curve> expectedCurves = ImmutableList.of(curve, scenario1Curve, scenario2Curve, scenario3Curve);
for (int scenarioIndex = 0; scenarioIndex < 4; scenarioIndex++)
{
// Check every point from 0 to 4 in steps of 0.1 is the same on the bumped curve and the expected curve
for (int xIndex = 0; xIndex <= 40; xIndex++)
{
double xValue = xIndex * 0.1;
Curve expectedCurve = expectedCurves[scenarioIndex];
Curve shiftedCurve = (Curve)shiftedCurveBox.getValue(scenarioIndex);
double shiftedY = shiftedCurve.yValue(xValue);
double expectedY = expectedCurve.yValue(xValue);
assertThat(shiftedY).overridingErrorMessage("Curve differed in scenario %d at x value %f, expected %f, actual %f", scenarioIndex, xValue, expectedY, shiftedY).isEqualTo(expectedY);
}
}
}
public virtual void stream()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
IList <int> list = box.ToList();
assertThat(list).isEqualTo(ImmutableList.of(27));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <T> com.opengamma.strata.data.scenario.MarketDataBox<T> getValue(com.opengamma.strata.data.MarketDataId<T> id)
public override MarketDataBox <T> getValue <T>(MarketDataId <T> id)
{
// this code exists to ensure that the error messages from market data building
// are exposed to users when the failures are not checked
// a special case for FX rates containing the same currency twice
if (id is FxRateId && ((FxRateId)id).Pair.Identity)
{
FxRateId fxRateId = (FxRateId)id;
FxRate identityRate = FxRate.of(fxRateId.Pair, 1);
return(MarketDataBox.ofSingleValue((T)identityRate));
}
// find the data and check it against the failures
Optional <MarketDataBox <T> > opt = underlying.findValue(id);
if (!opt.Present)
{
Failure failure = valueFailures.get(id);
if (failure != null)
{
throw new FailureException(failure);
}
throw new MarketDataNotFoundException(Messages.format("Market data not found for identifier '{}' of type '{}'", id, id.GetType().Name));
}
return(opt.get());
}
/// <summary>
/// Test that the box always returns the same value for any non-negative scenario index.
/// </summary>
public virtual void getValue()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
assertThat(box.getValue(0)).isEqualTo(27);
assertThat(box.getValue(int.MaxValue)).isEqualTo(27);
assertThrows(() => box.getValue(-1), typeof(System.ArgumentException));
}
public virtual void combineWithSingleBox()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
MarketDataBox <int> otherBox = MarketDataBox.ofSingleValue(15);
MarketDataBox <int> resultBox = box.combineWith(otherBox, (v1, v2) => v1 + v2);
assertThat(resultBox.SingleValue).True;
assertThat(resultBox.getValue(0)).isEqualTo(42);
}
//-------------------------------------------------------------------------
public virtual void getScenarioValueFromSingleValue()
{
MarketDataBox <double> box = MarketDataBox.ofSingleValue(9d);
TestMarketData marketData = new TestMarketData(box);
TestArrayKey key = new TestArrayKey();
TestDoubleArray array = marketData.getScenarioValue(key);
assertThat(array.values).isEqualTo(DoubleArray.of(9, 9, 9));
}
public virtual void buildInverse()
{
FxRateMarketDataFunction function = new FxRateMarketDataFunction();
MarketDataBox <double> quoteBox = MarketDataBox.ofSingleValue(1.1d);
ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addBox(QUOTE_ID, quoteBox).build();
MarketDataBox <FxRate> rateBox = function.build(FxRateId.of(CURRENCY_PAIR.inverse()), config(), marketData, REF_DATA);
assertThat(rateBox.SingleValue).True;
assertThat(rateBox.SingleValue).isEqualTo(FxRate.of(CURRENCY_PAIR, 1.1d));
}
/// <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.ofSingleValue(27);
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(28);
assertThat(scenarioBox.getValue(2)).isEqualTo(29);
}
// calibrates when there is a single group
private MarketDataBox <RatesCurveGroup> buildSingleCurveGroup(RatesCurveGroupDefinition configuredGroup, RatesCurveCalibrator calibrator, LocalDate valuationDate, IList <MarketDataBox <RatesCurveInputs> > inputBoxes, IDictionary <ObservableId, LocalDateDoubleTimeSeries> fixings, ReferenceData refData)
{
RatesCurveGroupDefinition filteredGroup = configuredGroup.filtered(valuationDate, refData);
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <RatesCurveInputs> inputs = inputBoxes.Select(MarketDataBox::getSingleValue).collect(toImmutableList());
MarketData inputValues = inputsByKey(valuationDate, inputs, fixings);
RatesCurveGroup curveGroup = buildGroup(filteredGroup, calibrator, inputValues, refData);
return(MarketDataBox.ofSingleValue(curveGroup));
}
//-------------------------------------------------------------------------
public virtual void test_defaultMethods()
{
ScenarioMarketData test = new ScenarioMarketDataAnonymousInnerClass(this);
assertThat(test.ValuationDate).isEqualTo(MarketDataBox.ofSingleValue(VAL_DATE));
assertThat(test.containsValue(ID1)).True;
assertThat(test.containsValue(ID2)).False;
assertThat(test.getValue(ID1)).isEqualTo(BOX1);
assertThrows(() => test.getValue(ID2), typeof(MarketDataNotFoundException));
assertThat(test.findValue(ID1)).hasValue(BOX1);
assertThat(test.findValue(ID2)).Empty;
}
public virtual void combineWithSingleBox()
{
MarketDataBox <int> box = MarketDataBox.ofScenarioValues(27, 28, 29);
MarketDataBox <int> otherBox = MarketDataBox.ofSingleValue(15);
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(43);
assertThat(resultBox.getValue(2)).isEqualTo(44);
}
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);
}
// one valuation date, one set of market data
private MarketDataBox <RatesCurveInputs> buildSingleCurveInputs <T1>(CurveDefinition filteredDefn, IDictionary <T1> marketData, LocalDate valuationDate, ReferenceData refData) where T1 : com.opengamma.strata.data.MarketDataId <T1>
{
// There is only a single map of values and single valuation date - create a single CurveInputs instance
CurveMetadata curveMetadata = filteredDefn.metadata(valuationDate, refData);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<? extends com.opengamma.strata.data.MarketDataId<?>, ?> singleMarketDataValues = com.opengamma.strata.collect.MapStream.of(marketData).mapValues(box -> box.getSingleValue()).toMap();
IDictionary <MarketDataId <object>, ?> singleMarketDataValues = MapStream.of(marketData).mapValues(box => box.SingleValue).toMap();
RatesCurveInputs curveInputs = RatesCurveInputs.of(singleMarketDataValues, curveMetadata);
return(MarketDataBox.ofSingleValue(curveInputs));
}
/// <summary>
/// Returns the inputs required for the curve if available.
/// <para>
/// If no market data is required to build the curve an empty set of inputs is returned.
/// If the curve requires inputs which are available in {@code marketData} they are returned.
/// If the curve requires inputs which are not available in {@code marketData} an exception is thrown
///
/// </para>
/// </summary>
/// <param name="curveDefn"> the curve definition </param>
/// <param name="marketData"> the market data </param>
/// <param name="groupName"> the name of the curve group being built </param>
/// <param name="obsSource"> the source of the observable market data </param>
/// <returns> the input data required for the curve if available </returns>
private MarketDataBox <RatesCurveInputs> curveInputs(CurveDefinition curveDefn, ScenarioMarketData marketData, CurveGroupName groupName, ObservableSource obsSource)
{
// only try to get inputs from the market data if the curve needs market data
if (requiresMarketData(curveDefn))
{
RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(groupName, curveDefn.Name, obsSource);
return(marketData.getValue(curveInputsId));
}
else
{
return(MarketDataBox.ofSingleValue(RatesCurveInputs.builder().build()));
}
}
/// <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 test_addValueMap()
{
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 eurUsdRate = FxRate.of(Currency.EUR, Currency.USD, 1.1);
IDictionary <FxRateId, FxRate> values = ImmutableMap.of(eurGbpId, eurGbpRate, eurUsdId, eurUsdRate);
ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValueMap(values).build();
assertEquals(marketData.ScenarioCount, 1);
assertEquals(marketData.Ids, ImmutableSet.of(eurGbpId, eurUsdId));
assertEquals(marketData.getValue(eurGbpId), MarketDataBox.ofSingleValue(eurGbpRate));
assertEquals(marketData.getValue(eurUsdId), MarketDataBox.ofSingleValue(eurUsdRate));
}
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 virtual void test_of_noScenarios()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, MarketDataBox<?>> dataMap = com.google.common.collect.ImmutableMap.of(ID1, MarketDataBox.empty());
IDictionary <MarketDataId <object>, MarketDataBox <object> > dataMap = ImmutableMap.of(ID1, MarketDataBox.empty());
ScenarioMarketData test = ScenarioMarketData.of(0, VAL_DATE, dataMap, ImmutableMap.of());
assertThat(test.ValuationDate).isEqualTo(MarketDataBox.ofSingleValue(VAL_DATE));
assertThat(test.containsValue(ID1)).True;
assertThat(test.containsValue(ID2)).False;
assertThat(test.getValue(ID1)).isEqualTo(MarketDataBox.empty());
assertThrows(() => test.getValue(ID2), typeof(MarketDataNotFoundException));
assertThat(test.findValue(ID1)).hasValue(MarketDataBox.empty());
assertThat(test.findValue(ID2)).Empty;
assertThat(test.Ids).isEqualTo(ImmutableSet.of(ID1));
assertThat(test.getTimeSeries(ID1)).isEqualTo(LocalDateDoubleTimeSeries.empty());
assertThat(test.getTimeSeries(ID2)).isEqualTo(LocalDateDoubleTimeSeries.empty());
}
public virtual void of_override()
{
ExtendedScenarioMarketData <string> test = ExtendedScenarioMarketData.of(ID1, VAL3, BASE_DATA);
assertEquals(test.Id, ID1);
assertEquals(test.Value, VAL3);
assertEquals(test.ValuationDate, MarketDataBox.ofSingleValue(VAL_DATE));
assertEquals(test.containsValue(ID1), true);
assertEquals(test.containsValue(ID2), true);
assertEquals(test.containsValue(ID3), false);
assertEquals(test.getValue(ID1), VAL3);
assertEquals(test.getValue(ID2), VAL2);
assertThrows(() => test.getValue(ID3), typeof(MarketDataNotFoundException));
assertEquals(test.Ids, ImmutableSet.of(ID1, ID2));
assertEquals(test.findValue(ID1), VAL3);
assertEquals(test.findValue(ID2), VAL2);
assertEquals(test.findValue(ID3), null);
assertEquals(test.getTimeSeries(ID4), TIME_SERIES);
}
//-------------------------------------------------------------------------
public virtual void test_of()
{
RepeatedScenarioMarketData test = RepeatedScenarioMarketData.of(2, BASE_DATA);
assertEquals(test.ScenarioCount, 2);
assertEquals(test.Underlying, BASE_DATA);
assertEquals(test.ValuationDate, MarketDataBox.ofSingleValue(VAL_DATE));
assertEquals(test.containsValue(ID1), true);
assertEquals(test.containsValue(ID2), true);
assertEquals(test.containsValue(ID3), false);
assertEquals(test.getValue(ID1), MarketDataBox.ofSingleValue(VAL1));
assertEquals(test.getValue(ID2), MarketDataBox.ofSingleValue(VAL2));
assertThrows(() => test.getValue(ID3), typeof(MarketDataNotFoundException));
assertEquals(test.findValue(ID1), MarketDataBox.ofSingleValue(VAL1));
assertEquals(test.findValue(ID2), MarketDataBox.ofSingleValue(VAL2));
assertEquals(test.findValue(ID3), null);
assertEquals(test.Ids, ImmutableSet.of(ID1, ID2));
assertEquals(test.findIds(ID1.MarketDataName), ImmutableSet.of(ID1));
assertEquals(test.getTimeSeries(ID4), TIME_SERIES);
}
public virtual void getScenarioValue()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
assertThrows(box.getScenarioValue, typeof(System.InvalidOperationException), "This box does not contain a scenario value");
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains an instance from a valuation date, map of values and time-series.
/// <para>
/// The valuation date and map of values must have the same number of scenarios.
///
/// </para>
/// </summary>
/// <param name="scenarioCount"> the number of scenarios </param>
/// <param name="valuationDate"> the valuation dates associated with all scenarios </param>
/// <param name="values"> the market data values, one for each scenario </param>
/// <param name="timeSeries"> the time-series </param>
/// <returns> a set of market data containing the values in the map </returns>
public static ImmutableScenarioMarketData of <T1, T2>(int scenarioCount, LocalDate valuationDate, IDictionary <T1> values, IDictionary <T2> timeSeries) where T1 : com.opengamma.strata.data.MarketDataId <T1> where T2 : com.opengamma.strata.data.ObservableId
{
return(of(scenarioCount, MarketDataBox.ofSingleValue(valuationDate), values, timeSeries));
}
public virtual void getMarketDataType()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
assertThat(box.MarketDataType).isEqualTo(typeof(Integer));
}
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 getSingleValue()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
assertThat(box.SingleValue).isEqualTo(27);
}
public virtual void getScenarioCount()
{
MarketDataBox <int> box = MarketDataBox.ofSingleValue(27);
assertThat(box.ScenarioCount).isEqualTo(-1);
}