private SingleScenarioMarketData(ScenarioMarketData marketData, int scenarioIndex) { JodaBeanUtils.notNull(marketData, "marketData"); this.marketData = marketData; this.scenarioIndex = scenarioIndex; validate(); }
// submits a task to the executor to be run private void runTask(CalculationTask task, ScenarioMarketData marketData, ReferenceData refData, System.Action <CalculationResults> consumer) { // the task is executed, with the result passed to the consumer // the consumer wraps the listener to ensure thread-safety System.Func <CalculationResults> taskExecutor = () => task.execute(marketData, refData); CompletableFuture.supplyAsync(taskExecutor, executor).thenAccept(consumer); }
//------------------------------------------------------------------------- public Results calculateMultiScenario(CalculationTasks tasks, ScenarioMarketData marketData, ReferenceData refData) { ResultsListener listener = new ResultsListener(); calculateMultiScenarioAsync(tasks, marketData, refData, listener); return(listener.result()); }
/// <summary> /// Test that inputs are correctly built from market data. /// </summary> public virtual void build() { FraCurveNode node1x4 = fraNode(1, "a"); FraCurveNode node2x5 = fraNode(2, "b"); FraCurveNode node3x6 = fraNode(3, "c"); InterpolatedNodalCurveDefinition curveDefn = InterpolatedNodalCurveDefinition.builder().name(CurveName.of("curve")).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(DayCounts.ACT_ACT_ISDA).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).nodes(node1x4, node2x5, node3x6).build(); RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(CurveGroupName.of("curve group")).addDiscountCurve(curveDefn, Currency.USD).build(); MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupDefn.Name, groupDefn).build(); QuoteId idA = QuoteId.of(StandardId.of("test", "a")); QuoteId idB = QuoteId.of(StandardId.of("test", "b")); QuoteId idC = QuoteId.of(StandardId.of("test", "c")); ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(VAL_DATE).addValue(idA, 1d).addValue(idB, 2d).addValue(idC, 3d).build(); RatesCurveInputsMarketDataFunction marketDataFunction = new RatesCurveInputsMarketDataFunction(); RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(groupDefn.Name, curveDefn.Name, ObservableSource.NONE); MarketDataBox <RatesCurveInputs> result = marketDataFunction.build(curveInputsId, marketDataConfig, marketData, REF_DATA); RatesCurveInputs curveInputs = result.SingleValue; assertThat(curveInputs.MarketData.get(idA)).isEqualTo(1d); assertThat(curveInputs.MarketData.get(idB)).isEqualTo(2d); assertThat(curveInputs.MarketData.get(idC)).isEqualTo(3d); IList <ParameterMetadata> expectedMetadata = ImmutableList.of(node1x4.metadata(VAL_DATE, REF_DATA), node2x5.metadata(VAL_DATE, REF_DATA), node3x6.metadata(VAL_DATE, REF_DATA)); assertThat(curveInputs.CurveMetadata.ParameterMetadata).hasValue(expectedMetadata); }
public virtual void test_parameter_secenarioDefinition() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<com.opengamma.strata.calc.marketdata.PerturbationMapping<?>> perturbationMapping = new java.util.ArrayList<>(); IList <PerturbationMapping <object> > perturbationMapping = new List <PerturbationMapping <object> >(); int nVolParams = EXP_VOLS.ParameterCount; int nScenarios = 3; PointShiftsBuilder builder = PointShifts.builder(ShiftType.SCALED); for (int i = 0; i < nVolParams; ++i) { object id = EXP_VOLS.getParameterMetadata(i).Identifier; for (int j = 0; j < nScenarios; ++j) { builder.addShift(j, id, Math.Pow(0.9, j)); } } ScenarioPerturbation <ParameterizedData> perturb = builder.build(); perturbationMapping.Add(PerturbationMapping.of(MarketDataFilter.ofId(VOL_ID), perturb)); ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(perturbationMapping); ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, MARKET_DATA, REF_DATA, scenarioDefinition); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray pvs = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; for (int i = 0; i < nScenarios; ++i) { int index = i; BlackFxOptionSmileVolatilities shiftedSmile = EXP_VOLS.withPerturbation((j, v, m) => Math.Pow(0.9, index) * v); CurrencyAmount pv = PRICER.presentValue(OPTION_TRADE.resolve(REF_DATA), EXP_RATES, shiftedSmile).convertedTo(USD, EXP_RATES); assertEquals(pvs.get(i), pv); } }
/// <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 test_quote_secenarioDefinition() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<com.opengamma.strata.calc.marketdata.PerturbationMapping<?>> perturbationMapping = new java.util.ArrayList<>(); IList <PerturbationMapping <object> > perturbationMapping = new List <PerturbationMapping <object> >(); int nScenarios = 3; foreach (KeyValuePair <QuoteId, double> entry in MARKET_QUOTES.entrySet()) { DoubleArray shifts = DoubleArray.of(nScenarios, n => Math.Pow(0.9, n)); ScenarioPerturbation <double> perturb = GenericDoubleShifts.of(ShiftType.SCALED, shifts); perturbationMapping.Add(PerturbationMapping.of(MarketDataFilter.ofId(entry.Key), perturb)); } ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(perturbationMapping); ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, MARKET_DATA, REF_DATA, scenarioDefinition); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray pvs = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; for (int i = 0; i < nScenarios; ++i) { ImmutableMap.Builder <QuoteId, double> builder = ImmutableMap.builder(); foreach (KeyValuePair <QuoteId, double> entry in MARKET_QUOTES.entrySet()) { builder.put(entry.Key, entry.Value * Math.Pow(0.9, i)); } ImmutableMarketData shiftedMarketData = ImmutableMarketData.builder(VALUATION_DATE).addValueMap(builder.build()).addValueMap(MARKET_FX_QUOTES).build(); MarketData shiftedMarketDataCalibrated = StandardComponents.marketDataFactory().create(REQUIREMENTS, CONFIG, shiftedMarketData, REF_DATA); Results shiftedResults = CALC_RUNNER.calculate(RULES, TARGETS, COLUMN, shiftedMarketDataCalibrated, REF_DATA); CurrencyAmount pv = shiftedResults.get(0, 0, typeof(CurrencyAmount)).Value; assertEquals(pvs.get(i), pv); } }
/// <summary> /// Test that ScenarioArrays containing a single value are unwrapped when calling calculateAsync(). /// </summary> public virtual void unwrapScenarioResultsAsync() { ScenarioArray <string> scenarioResult = ScenarioArray.of("foo"); ScenarioResultFunction fn = new ScenarioResultFunction(TestingMeasures.PRESENT_VALUE, scenarioResult); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL); CalculationTask task = CalculationTask.of(TARGET, fn, cell); Column column = Column.of(TestingMeasures.PRESENT_VALUE); CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column)); // using the direct executor means there is no need to close/shutdown the runner CalculationTaskRunner test = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService()); Listener listener = new Listener(); MarketData marketData = MarketData.empty(VAL_DATE); test.calculateAsync(tasks, marketData, REF_DATA, listener); CalculationResult calculationResult1 = listener.result; //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result1 = calculationResult1.getResult(); Result <object> result1 = calculationResult1.Result; // Check the result contains the string directly, not the result wrapping the string assertThat(result1).hasValue("foo"); test.calculateMultiScenarioAsync(tasks, ScenarioMarketData.of(1, marketData), REF_DATA, listener); CalculationResult calculationResult2 = listener.result; //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result2 = calculationResult2.getResult(); Result <object> result2 = calculationResult2.Result; // Check the result contains the scenario result wrapping the string assertThat(result2).hasValue(scenarioResult); }
// calculates the result //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: private java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData) private IDictionary <Measure, Result <object> > calculate(ScenarioMarketData marketData, ReferenceData refData) { try { ISet <Measure> requestedMeasures = Measures; ISet <Measure> supportedMeasures = function.supportedMeasures(); ISet <Measure> measures = Sets.intersection(requestedMeasures, supportedMeasures); //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<?>> map = com.google.common.collect.ImmutableMap.of(); IDictionary <Measure, Result <object> > map = ImmutableMap.of(); if (measures.Count > 0) { map = function.calculate(target, measures, parameters, marketData, refData); } // check if result does not contain all requested measures //JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the java.util.Collection 'containsAll' method: if (!map.Keys.containsAll(requestedMeasures)) { return(handleMissing(requestedMeasures, supportedMeasures, map)); } return(map); } catch (Exception ex) { return(handleFailure(ex)); } }
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 test_calculate_failure() { BillTradeCalculationFunction <BillTrade> function = BillTradeCalculationFunction.TRADE; ScenarioMarketData md = marketData(); ISet <Measure> measures = ImmutableSet.of(Measures.FORWARD_FX_RATE); assertTrue(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)[Measures.FORWARD_FX_RATE].Failure); }
public void calculateAsync(CalculationTasks tasks, MarketData marketData, ReferenceData refData, CalculationListener listener) { // the listener is decorated to unwrap ScenarioArrays containing a single result ScenarioMarketData md = ScenarioMarketData.of(1, marketData); UnwrappingListener unwrappingListener = new UnwrappingListener(listener); calculateMultiScenarioAsync(tasks, md, refData, unwrappingListener); }
/// <summary> /// Test that a failure is returned if there is no config for the curve group. /// </summary> public virtual void buildMissingGroupConfig() { RatesCurveInputsMarketDataFunction marketDataFunction = new RatesCurveInputsMarketDataFunction(); RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(CurveGroupName.of("curve group"), CurveName.of("curve"), ObservableSource.NONE); ScenarioMarketData emptyData = ScenarioMarketData.empty(); assertThrows(() => marketDataFunction.build(curveInputsId, MarketDataConfig.empty(), emptyData, REF_DATA), typeof(System.ArgumentException), "No configuration found for type .*"); }
/// <summary> /// Creates an instance. </summary> /// <param name="underlying1"> the value of the property, not null </param> /// <param name="underlying2"> the value of the property, not null </param> /// <param name="scenarioCount"> the value of the property </param> internal CombinedScenarioMarketData(ScenarioMarketData underlying1, ScenarioMarketData underlying2, int scenarioCount) { JodaBeanUtils.notNull(underlying1, "underlying1"); JodaBeanUtils.notNull(underlying2, "underlying2"); this.underlying1 = underlying1; this.underlying2 = underlying2; this.scenarioCount = scenarioCount; }
public virtual void of_badScenarios() { //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.ofScenarioValues(VAL1)); IDictionary <MarketDataId <object>, MarketDataBox <object> > dataMap = ImmutableMap.of(ID1, MarketDataBox.ofScenarioValues(VAL1)); IDictionary <ObservableId, LocalDateDoubleTimeSeries> tsMap = ImmutableMap.of(ID1, TIME_SERIES); assertThrows(() => ScenarioMarketData.of(2, VAL_DATE, dataMap, tsMap), typeof(System.ArgumentException)); }
// extract the fixings from the input data private IDictionary <ObservableId, LocalDateDoubleTimeSeries> extractFixings(ScenarioMarketData marketData) { IDictionary <ObservableId, LocalDateDoubleTimeSeries> fixings = new Dictionary <ObservableId, LocalDateDoubleTimeSeries>(); foreach (ObservableId id in marketData.TimeSeriesIds) { fixings[id] = marketData.getTimeSeries(id); } return(fixings); }
private ExtendedScenarioMarketData(MarketDataId <T> id, MarketDataBox <T> value, ScenarioMarketData underlying) { JodaBeanUtils.notNull(id, "id"); JodaBeanUtils.notNull(value, "value"); JodaBeanUtils.notNull(underlying, "underlying"); this.id = id; this.value = value; this.underlying = underlying; validate(); }
/// <summary> /// Test that a failure is returned if there is config for the curve group but it doesn't contain the named curve. /// </summary> public virtual void buildMissingCurveDefinition() { RatesCurveInputsMarketDataFunction marketDataFunction = new RatesCurveInputsMarketDataFunction(); RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(CurveGroupName.of("curve group"), CurveName.of("curve"), ObservableSource.NONE); RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(CurveGroupName.of("curve group")).build(); MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupDefn.Name, groupDefn).build(); ScenarioMarketData emptyData = ScenarioMarketData.empty(); assertThrows(() => marketDataFunction.build(curveInputsId, marketDataConfig, emptyData, REF_DATA), typeof(System.ArgumentException), "No curve named .*"); }
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)); }
// obtains the data and calculates the grid of results private static void calculate(CalculationRunner runner) { // the trade that will have measures calculated IList <Trade> trades = ImmutableList.of(createVanillaFixedVsLibor3mSwap()); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE), Column.of(Measures.PV01_CALIBRATED_SUM)); // use the built-in example market data ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder(); // the complete set of rules for calculating measures LocalDate valuationDate = LocalDate.of(2014, 1, 22); CalculationFunctions functions = StandardComponents.calculationFunctions(); CalculationRules rules = CalculationRules.of(functions, Currency.USD, marketDataBuilder.ratesLookup(valuationDate)); // mappings that select which market data to apply perturbations to // this applies the perturbations above to all curves PerturbationMapping <Curve> mapping = PerturbationMapping.of(MarketDataFilter.ofIdType(typeof(CurveId)), CurveParallelShifts.absolute(0, ONE_BP)); // create a scenario definition containing the single mapping above // this creates two scenarios - one for each perturbation in the mapping ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(mapping); // build a market data snapshot for the valuation date MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate); // the reference data, such as holidays and securities ReferenceData refData = ReferenceData.standard(); // calculate the results MarketDataRequirements reqs = MarketDataRequirements.of(rules, trades, columns, refData); ScenarioMarketData scenarioMarketData = marketDataFactory().createMultiScenario(reqs, MarketDataConfig.empty(), marketData, refData, scenarioDefinition); Results results = runner.calculateMultiScenario(rules, trades, columns, scenarioMarketData, refData); // TODO Replace the results processing below with a report once the reporting framework supports scenarios // The results are lists of currency amounts containing one value for each scenario //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pvList = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 0).getValue(); ScenarioArray <object> pvList = (ScenarioArray <object>)results.get(0, 0).Value; //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.scenario.ScenarioArray<?> pv01List = (com.opengamma.strata.data.scenario.ScenarioArray<?>) results.get(0, 1).getValue(); ScenarioArray <object> pv01List = (ScenarioArray <object>)results.get(0, 1).Value; double pvBase = ((CurrencyAmount)pvList.get(0)).Amount; double pvShifted = ((CurrencyAmount)pvList.get(1)).Amount; double pv01Base = ((CurrencyAmount)pv01List.get(0)).Amount; NumberFormat numberFormat = new DecimalFormat("###,##0.00", new DecimalFormatSymbols(Locale.ENGLISH)); Console.WriteLine(" PV (base) = " + numberFormat.format(pvBase)); Console.WriteLine(" PV (1 bp curve shift) = " + numberFormat.format(pvShifted)); Console.WriteLine("PV01 (algorithmic differentiation) = " + numberFormat.format(pv01Base)); Console.WriteLine(" PV01 (finite difference) = " + numberFormat.format(pvShifted - pvBase)); }
public virtual void test_scenarioMarketData() { ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, SCENARIO_MARKET_DATA, REF_DATA, ScenarioDefinition.empty()); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray pvs = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; CurrencyAmount pv0 = PRICER.presentValue(OPTION_TRADE.resolve(REF_DATA), EXP_RATES, EXP_VOLS).convertedTo(USD, EXP_RATES); CurrencyAmount pv1 = PRICER.presentValue(OPTION_TRADE.resolve(REF_DATA), EXP_RATES_1, EXP_VOLS_1).convertedTo(USD, EXP_RATES_1); assertEquals(pvs.get(0), pv0); assertEquals(pvs.get(1), pv1); }
public override ScenarioMarketData combinedWith(ScenarioMarketData other) { if (other is ImmutableScenarioMarketData) { return(combinedWith((ImmutableScenarioMarketData)other)); } else { return(ScenarioMarketData.this.combinedWith(other)); } }
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); }
public virtual void test_presentValue() { GenericSecurityPositionCalculationFunction function = new GenericSecurityPositionCalculationFunction(); ScenarioMarketData md = marketData(); double unitPv = (MARKET_PRICE / TICK_SIZE) * TICK_VALUE; CurrencyAmount expectedPv = CurrencyAmount.of(CURRENCY, unitPv * QUANTITY); ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE); assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))); }
public void calculateMultiScenarioAsync(CalculationTasks tasks, ScenarioMarketData marketData, ReferenceData refData, CalculationListener listener) { IList <CalculationTask> taskList = tasks.Tasks; // the listener is invoked via this wrapper // the wrapper ensures thread-safety for the listener // it also calls the listener with single CalculationResult cells, not CalculationResults System.Action <CalculationResults> consumer = new ListenerWrapper(listener, taskList.Count, tasks.Targets, tasks.Columns); // run each task using the executor taskList.ForEach(task => runTask(task, marketData, refData, consumer)); }
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_simpleMeasures() { OvernightFutureTradeCalculationFunction <OvernightFutureTrade> function = OvernightFutureTradeCalculationFunction.TRADE; ScenarioMarketData md = marketData(FORWARD_CURVE_ID.CurveName); RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0)); double expectedPrice = TRADE_PRICER.price(RESOLVED_TRADE, provider); CurrencyAmount expectedPv = TRADE_PRICER.presentValue(RESOLVED_TRADE, provider, MARKET_PRICE / 100d); double expectedParSpread = TRADE_PRICER.parSpread(RESOLVED_TRADE, provider, MARKET_PRICE / 100d); ISet <Measure> measures = ImmutableSet.of(Measures.UNIT_PRICE, Measures.PRESENT_VALUE, Measures.PAR_SPREAD, Measures.RESOLVED_TARGET); assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.UNIT_PRICE, Result.success(DoubleScenarioArray.of(ImmutableList.of(expectedPrice)))).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.PAR_SPREAD, Result.success(DoubleScenarioArray.of(ImmutableList.of(expectedParSpread)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RESOLVED_TRADE)); }
public virtual void test_simpleMeasures() { CmsTradeCalculationFunction function = new CmsTradeCalculationFunction(); ScenarioMarketData md = marketData(); RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0)); SabrExtrapolationReplicationCmsTradePricer pricer = new SabrExtrapolationReplicationCmsTradePricer(new SabrExtrapolationReplicationCmsProductPricer(new SabrExtrapolationReplicationCmsLegPricer(SabrExtrapolationReplicationCmsPeriodPricer.of(CUT_OFF_STRIKE, MU)))); ResolvedCmsTrade resolved = TRADE.resolve(REF_DATA); MultiCurrencyAmount expectedPv = pricer.presentValue(resolved, provider, VOLS); ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.RESOLVED_TARGET); assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(TRADE.resolve(REF_DATA))); }
public virtual void test_simpleMeasures() { SwaptionTradeCalculationFunction function = new SwaptionTradeCalculationFunction(); ScenarioMarketData md = marketData(); RatesProvider provider = RATES_LOOKUP.ratesProvider(md.scenario(0)); NormalSwaptionTradePricer pricer = NormalSwaptionTradePricer.DEFAULT; ResolvedSwaptionTrade resolved = TRADE.resolve(REF_DATA); CurrencyAmount expectedPv = pricer.presentValue(resolved, provider, NORMAL_VOL_SWAPTION_PROVIDER_USD); ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.RESOLVED_TARGET); assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RTRADE)); }
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)); }