//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(FxSingleBarrierOptionTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product FxSingleBarrierOption product = trade.Product; CurrencyPair currencyPair = product.CurrencyPair; // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(ImmutableSet.of(currencyPair.Base, currencyPair.Counter)); FxOptionMarketDataLookup optionLookup = parameters.getParameter(typeof(FxOptionMarketDataLookup)); FunctionRequirements optionReqs = optionLookup.requirements(currencyPair); return(ratesReqs.combinedWith(optionReqs)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(IborCapFloorTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product IborCapFloor product = trade.Product; ISet <Currency> currencies = product.allPaymentCurrencies(); ISet <Index> indices = product.allIndices(); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(currencies, indices); IborCapFloorMarketDataLookup capFloorLookup = parameters.getParameter(typeof(IborCapFloorMarketDataLookup)); FunctionRequirements capFloorReqs = capFloorLookup.requirements(product.CapFloorLeg.Index); return(ratesReqs.combinedWith(capFloorReqs)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(SwaptionTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product Swaption product = trade.Product; Currency currency = product.Currency; IborIndex index = product.Index; // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(currency, index); SwaptionMarketDataLookup swaptionLookup = parameters.getParameter(typeof(SwaptionMarketDataLookup)); FunctionRequirements swaptionReqs = swaptionLookup.requirements(index); return(ratesReqs.combinedWith(swaptionReqs)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product CapitalIndexedBond product = target.Product; Currency currency = product.Currency; SecurityId securityId = product.SecurityId; LegalEntityId legalEntityId = product.LegalEntityId; // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(ImmutableSet.of(), ImmutableSet.of(product.RateCalculation.Index)); LegalEntityDiscountingMarketDataLookup ledLookup = parameters.getParameter(typeof(LegalEntityDiscountingMarketDataLookup)); FunctionRequirements ledReqs = ledLookup.requirements(securityId, legalEntityId, currency); return(ratesReqs.combinedWith(ledReqs)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(CmsTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product Cms product = trade.Product; ISet <Currency> currencies = product.allPaymentCurrencies(); IborIndex cmsIndex = trade.Product.CmsLeg.UnderlyingIndex; ISet <Index> payIndices = trade.Product.allRateIndices(); ISet <Index> indices = ImmutableSet.builder <Index>().add(cmsIndex).addAll(payIndices).build(); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(currencies, indices); SwaptionMarketDataLookup swaptionLookup = parameters.getParameter(typeof(SwaptionMarketDataLookup)); FunctionRequirements swaptionReqs = swaptionLookup.requirements(cmsIndex); return(ratesReqs.combinedWith(swaptionReqs)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(FxSingleTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product ImmutableSet <Currency> currencies = trade.Product.CurrencyPair.toSet(); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); return(ratesLookup.requirements(currencies)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product IborFutureOption option = target.Product; QuoteId optionQuoteId = QuoteId.of(option.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE); Currency currency = option.Currency; IborIndex index = option.Index; // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(currency, index); IborFutureOptionMarketDataLookup optionLookup = parameters.getParameter(typeof(IborFutureOptionMarketDataLookup)); FunctionRequirements optionReqs = optionLookup.requirements(index); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.google.common.collect.ImmutableSet<com.opengamma.strata.data.MarketDataId<?>> valueReqs = com.google.common.collect.ImmutableSet.builder<com.opengamma.strata.data.MarketDataId<?>>().add(optionQuoteId).addAll(ratesReqs.getValueRequirements()).addAll(optionReqs.getValueRequirements()).build(); ImmutableSet <MarketDataId <object> > valueReqs = ImmutableSet.builder <MarketDataId <object> >().add(optionQuoteId).addAll(ratesReqs.ValueRequirements).addAll(optionReqs.ValueRequirements).build(); return(ratesReqs.toBuilder().valueRequirements(valueReqs).build()); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product Bill product = target.Product; // use lookup to build requirements LegalEntityDiscountingMarketDataLookup lookup = parameters.getParameter(typeof(LegalEntityDiscountingMarketDataLookup)); return(lookup.requirements(product.SecurityId, product.LegalEntityId, product.Currency)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(SwapTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product Swap product = trade.Product; ImmutableSet <Currency> currencies = product.allPaymentCurrencies(); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); return(ratesLookup.requirements(currencies, product.allIndices())); }
//------------------------------------------------------------------------- //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.product.capfloor.IborCapFloorTrade trade, java.util.Set<com.opengamma.strata.calc.Measure> measures, com.opengamma.strata.calc.runner.CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData scenarioMarketData, com.opengamma.strata.basics.ReferenceData refData) public virtual IDictionary <Measure, Result <object> > calculate(IborCapFloorTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData) { // expand the trade once for all measures and all scenarios ResolvedIborCapFloorTrade resolved = trade.resolve(refData); RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); RatesScenarioMarketData ratesMarketData = ratesLookup.marketDataView(scenarioMarketData); IborCapFloorMarketDataLookup capFloorLookup = parameters.getParameter(typeof(IborCapFloorMarketDataLookup)); IborCapFloorScenarioMarketData capFloorMarketData = capFloorLookup.marketDataView(scenarioMarketData); // loop around measures, calculating all scenarios for one measure //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<?>> results = new java.util.HashMap<>(); IDictionary <Measure, Result <object> > results = new Dictionary <Measure, Result <object> >(); foreach (Measure measure in measures) { results[measure] = calculate(measure, resolved, ratesMarketData, capFloorMarketData); } return(results); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(BulletPaymentTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product BulletPayment product = trade.Product; Currency currency = product.Currency; // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); return(ratesLookup.requirements(currency)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product BondFutureOption option = target.Product; BondFuture future = option.UnderlyingFuture; // use lookup to build requirements QuoteId optionQuoteId = QuoteId.of(option.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE); FunctionRequirements freqs = FunctionRequirements.builder().valueRequirements(optionQuoteId).outputCurrencies(future.Currency, option.Currency).build(); LegalEntityDiscountingMarketDataLookup ledLookup = parameters.getParameter(typeof(LegalEntityDiscountingMarketDataLookup)); foreach (FixedCouponBond bond in future.DeliveryBasket) { freqs = freqs.combinedWith(ledLookup.requirements(bond.SecurityId, bond.LegalEntityId, bond.Currency)); } BondFutureOptionMarketDataLookup optionLookup = parameters.getParameter(typeof(BondFutureOptionMarketDataLookup)); FunctionRequirements optionReqs = optionLookup.requirements(future.SecurityId); return(freqs.combinedWith(optionReqs)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(CdsIndexTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product CdsIndex product = trade.Product; StandardId legalEntityId = product.CdsIndexId; Currency currency = product.Currency; // use lookup to build requirements CreditRatesMarketDataLookup lookup = parameters.getParameter(typeof(CreditRatesMarketDataLookup)); return(lookup.requirements(legalEntityId, currency)); }
//------------------------------------------------------------------------- //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(T target, java.util.Set<com.opengamma.strata.calc.Measure> measures, com.opengamma.strata.calc.runner.CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData scenarioMarketData, com.opengamma.strata.basics.ReferenceData refData) public virtual IDictionary <Measure, Result <object> > calculate(T target, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData) { // resolve the trade once for all measures and all scenarios ResolvedCapitalIndexedBondTrade resolved = target.resolve(refData); // use lookup to query market data RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); RatesScenarioMarketData ratesMarketData = ratesLookup.marketDataView(scenarioMarketData); LegalEntityDiscountingMarketDataLookup ledLookup = parameters.getParameter(typeof(LegalEntityDiscountingMarketDataLookup)); LegalEntityDiscountingScenarioMarketData legalEntityMarketData = ledLookup.marketDataView(scenarioMarketData); // loop around measures, calculating all scenarios for one measure //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<?>> results = new java.util.HashMap<>(); IDictionary <Measure, Result <object> > results = new Dictionary <Measure, Result <object> >(); foreach (Measure measure in measures) { results[measure] = calculate(measure, resolved, ratesMarketData, legalEntityMarketData); } return(results); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(FxNdfTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product FxNdf fx = trade.Product; Currency settleCurrency = fx.SettlementCurrency; Currency otherCurrency = fx.NonDeliverableCurrency; ImmutableSet <Currency> currencies = ImmutableSet.of(settleCurrency, otherCurrency); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); return(ratesLookup.requirements(currencies)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(FraTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product Fra product = trade.Product; ISet <IborIndex> indices = new HashSet <IborIndex>(); indices.Add(product.Index); product.IndexInterpolated.ifPresent(indices.add); ImmutableSet <Currency> currencies = ImmutableSet.of(product.Currency); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); return(ratesLookup.requirements(currencies, indices)); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product Dsf product = target.Product; QuoteId quoteId = QuoteId.of(target.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE); ImmutableSet <Index> indices = product.UnderlyingSwap.allIndices(); ImmutableSet <Currency> currencies = ImmutableSet.of(product.Currency); // use lookup to build requirements RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup)); FunctionRequirements ratesReqs = ratesLookup.requirements(currencies, indices); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.google.common.collect.ImmutableSet<com.opengamma.strata.data.MarketDataId<?>> valueReqs = com.google.common.collect.ImmutableSet.builder<com.opengamma.strata.data.MarketDataId<?>>().add(quoteId).addAll(ratesReqs.getValueRequirements()).build(); ImmutableSet <MarketDataId <object> > valueReqs = ImmutableSet.builder <MarketDataId <object> >().add(quoteId).addAll(ratesReqs.ValueRequirements).build(); return(ratesReqs.toBuilder().valueRequirements(valueReqs).build()); }
//------------------------------------------------------------------------- public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData) { // extract data from product BondFuture product = target.Product; QuoteId quoteId = QuoteId.of(product.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE); Currency currency = product.Currency; // use lookup to build requirements FunctionRequirements freqs = FunctionRequirements.builder().valueRequirements(quoteId).outputCurrencies(currency).build(); LegalEntityDiscountingMarketDataLookup ledLookup = parameters.getParameter(typeof(LegalEntityDiscountingMarketDataLookup)); foreach (FixedCouponBond bond in product.DeliveryBasket) { freqs = freqs.combinedWith(ledLookup.requirements(bond.SecurityId, bond.LegalEntityId, bond.Currency)); } return(freqs); }