//------------------------------------------------------------------------- public virtual void test_ofIdType() { MarketDataFilter <string, MarketDataId <string> > test = MarketDataFilter.ofIdType(typeof(TestId)); assertEquals(test.MarketDataIdType, typeof(TestId)); assertTrue(test.matches(new TestId("a"), null, REF_DATA)); }
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); } }
public void OnMergeHandleIfThisLadderLevelIsNull(int levels) { var newDataFilter = new MarketDataFilter().WithLadderLevels(levels); _marketDataFilter.Merge(newDataFilter); Assert.Equal(levels, _marketDataFilter.LadderLevels); }
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); } }
private void OnNewBarOpen(object sender, BarEventArgs args) { if (NewBarOpen != null) { CThostFtdcDepthMarketDataField DepthMarket; Instrument inst = InstrumentManager.Instruments[args.Instrument.Symbol]; string altSymbol = inst.GetSymbol(Name); Bar bar = args.Bar; if (_dictDepthMarketData.TryGetValue(altSymbol, out DepthMarket)) { bar = new Bar(args.Bar); bar.OpenInt = (long)DepthMarket.OpenInterest; } #if OQ if (null != MarketDataFilter) { Bar b = MarketDataFilter.FilterBarOpen(bar, args.Instrument.Symbol); if (null != b) { NewBarOpen(this, new BarEventArgs(b, args.Instrument, this)); } } else #endif { NewBarOpen(this, new BarEventArgs(bar, args.Instrument, this)); } } }
public void HandleMergeIfThisFieldsAreNull() { var newDataFilter = new MarketDataFilter().WithBestPrices(); _marketDataFilter.Merge(newDataFilter); Assert.Contains("EX_BEST_OFFERS", _marketDataFilter.Fields); Assert.Single(_marketDataFilter.Fields); }
public virtual void test_ofName() { MarketDataFilter <string, NamedMarketDataId <string> > test = MarketDataFilter.ofName(new TestingName("a")); assertEquals(test.MarketDataIdType, typeof(NamedMarketDataId)); assertTrue(test.matches(new TestingNamedId("a"), null, REF_DATA)); assertFalse(test.matches(new TestingNamedId("b"), null, REF_DATA)); }
public void MergeTwoLadderLevels() { _marketDataFilter.WithLadderLevels(3); var newDataFilter = new MarketDataFilter().WithLadderLevels(5); _marketDataFilter.Merge(newDataFilter); Assert.Equal(5, _marketDataFilter.LadderLevels); }
public async Task Subscribe(MarketFilter marketFilter, MarketDataFilter dataFilter) { Actions += "S"; MarketId = marketFilter?.MarketIds?.SingleOrDefault(); Fields = dataFilter?.Fields; LadderLevels = dataFilter?.LadderLevels; await Task.CompletedTask; }
public async Task OnSubscribeMarketDataFilterIsSet() { var dataFilter = new MarketDataFilter().WithBestPrices(); var subscriptionMessage = new SubscriptionMessageStub("marketSubscription", 1) .WithMarketDateFilter(dataFilter) .ToJson(); await Subscription.Subscribe(null, dataFilter); Assert.Equal(subscriptionMessage, Writer.LastLineWritten); }
public void MergeTwoFieldHashSets() { _marketDataFilter.WithBestPrices(); var newDataFilter = new MarketDataFilter().WithLastTradedPrice(); _marketDataFilter.Merge(newDataFilter); Assert.Contains("EX_BEST_OFFERS", _marketDataFilter.Fields); Assert.Contains("EX_LTP", _marketDataFilter.Fields); Assert.Equal(2, _marketDataFilter.Fields.Count); }
// 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 coverage() { MarketDataFilter <string, MarketDataId <string> > test1 = MarketDataFilter.ofIdType(typeof(TestId)); coverImmutableBean((ImmutableBean)test1); MarketDataFilter <string, MarketDataId <string> > test2 = MarketDataFilter.ofId(new TestId("a")); coverImmutableBean((ImmutableBean)test2); MarketDataFilter <string, NamedMarketDataId <string> > test3 = MarketDataFilter.ofName(new TestingName("a")); coverImmutableBean((ImmutableBean)test3); }
private MarketDataFilter GetMergedDataFilters() { var dataFiler = new MarketDataFilter(); foreach (var marketDataFilter in _strategies.Select(s => s.DataFilter).ToList()) { dataFiler.Merge(marketDataFilter); } return(dataFiler); }
private void OnNewBarOpen(object sender, BarEventArgs args) { if (NewBarOpen != null) { Bar bar = args.Bar; if (null != MarketDataFilter) { Bar b = MarketDataFilter.FilterBarOpen(bar, args.Instrument.Symbol); if (null != b) { NewBarOpen(this, new BarEventArgs(b, args.Instrument, this)); } } else { NewBarOpen(this, new BarEventArgs(bar, args.Instrument, this)); } } }
public virtual void test_builtData() { //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); ImmutableMarketData dataWithSurface = ImmutableMarketData.builder(VALUATION_DATE).addValueMap(MARKET_QUOTES).addValueMap(MARKET_FX_QUOTES).addValue(VOL_ID, EXP_VOLS).addValue(RatesCurveGroupId.of(CURVE_GROUP_NAME), RatesCurveGroup.ofCurves(CURVE_GROUP_DEFINITION, EXP_RATES.toImmutableRatesProvider().DiscountCurves.values())).build(); ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, dataWithSurface, REF_DATA, scenarioDefinition); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray computed = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; CurrencyAmount expected = PRICER.presentValue(OPTION_TRADE.resolve(REF_DATA), EXP_RATES, EXP_VOLS).convertedTo(USD, EXP_RATES); // dependency graph is absent, thus scenarios are not created assertTrue(computed.ScenarioCount == 1); assertEquals(computed.get(0), expected); }
public SubscriptionMessageStub WithMarketDateFilter(MarketDataFilter marketDataFilter) { MarketDataFilter = marketDataFilter; return(this); }
// 构造函数不能省 public MyExtFilter(MarketDataProvider provider, MarketDataFilter filter) : base(provider, "Simulator")//如果使用3.9.2版默认的Simulator { this.filter = filter; }
// 构造函数不能省 public MyExtFilter(MarketDataProvider provider, MarketDataFilter filter) : base(provider) { this.filter = filter; }
private static ScenarioDefinition buildHistoricalScenarios(IDictionary <LocalDate, RatesCurveGroup> historicalCurves, IList <LocalDate> scenarioDates) { // extract the curves to perturb //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <Curve> usdDiscountCurves = scenarioDates.Select(date => historicalCurves[date]).Select(group => group.findDiscountCurve(Currency.USD).get()).collect(toImmutableList()); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <Curve> libor3mCurves = scenarioDates.Select(date => historicalCurves[date]).Select(group => group.findForwardCurve(IborIndices.USD_LIBOR_3M).get()).collect(toImmutableList()); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <Curve> libor6mCurves = scenarioDates.Select(date => historicalCurves[date]).Select(group => group.findForwardCurve(IborIndices.USD_LIBOR_6M).get()).collect(toImmutableList()); // create mappings which will cause the point shift perturbations generated above // to be applied to the correct curves PerturbationMapping <ParameterizedData> discountCurveMappings = PerturbationMapping.of(MarketDataFilter.ofName(CurveName.of("USD-Disc")), buildShifts(usdDiscountCurves)); PerturbationMapping <ParameterizedData> libor3mMappings = PerturbationMapping.of(MarketDataFilter.ofName(CurveName.of("USD-3ML")), buildShifts(libor3mCurves)); PerturbationMapping <ParameterizedData> libor6mMappings = PerturbationMapping.of(MarketDataFilter.ofName(CurveName.of("USD-6ML")), buildShifts(libor6mCurves)); // create a scenario definition from these mappings return(ScenarioDefinition.ofMappings(discountCurveMappings, libor3mMappings, libor6mMappings)); }