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