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