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