//-------------------------------------------------------------------------
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
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(GenericSecurityPosition position, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
QuoteId id = QuoteId.of(position.SecurityId.StandardId);
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.of(id)).outputCurrencies(position.Currency).build());
}
//-------------------------------------------------------------------------
//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.fxopt.FxSingleBarrierOptionTrade 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(FxSingleBarrierOptionTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData)
{
// expand the trade once for all measures and all scenarios
ResolvedFxSingleBarrierOptionTrade resolved = trade.resolve(refData);
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
RatesScenarioMarketData ratesMarketData = ratesLookup.marketDataView(scenarioMarketData);
FxOptionMarketDataLookup optionLookup = parameters.getParameter(typeof(FxOptionMarketDataLookup));
FxOptionScenarioMarketData optionMarketData = optionLookup.marketDataView(scenarioMarketData);
FxSingleBarrierOptionMethod method = parameters.findParameter(typeof(FxSingleBarrierOptionMethod)).orElse(FxSingleBarrierOptionMethod.BLACK);
// 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, optionMarketData, method);
}
return(results);
}
//-------------------------------------------------------------------------
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()));
}
private Column(ColumnName name, Measure measure, ReportingCurrency reportingCurrency, CalculationParameters parameters)
{
JodaBeanUtils.notNull(name, "name");
JodaBeanUtils.notNull(measure, "measure");
this.name = name;
this.measure = measure;
this.reportingCurrency = reportingCurrency;
this.parameters = parameters;
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains an instance that will calculate the specified measure.
/// <para>
/// The column name will be the same as the name of the measure.
/// No calculation parameters are provided, thus the parameters from <seealso cref="CalculationRules"/> will be used.
/// Currency conversion is controlled by the reporting currency in {@code CalculationRules}.
///
/// </para>
/// </summary>
/// <param name="measure"> the measure to be calculated </param>
/// <returns> a column with the specified measure </returns>
public static Column of(Measure measure)
{
ColumnName name = ColumnName.of(measure);
return(new Column(name, measure, null, CalculationParameters.empty()));
}
public FunctionRequirements requirements(TestTarget target, CalculationParameters parameters, ReferenceData refData)
{
return(FunctionRequirements.builder().valueRequirements(TestObservableId.of("a"), TestObservableId.of("b")).timeSeriesRequirements(TestObservableId.of("c")).outputCurrencies(Currency.GBP).build());
}
//-------------------------------------------------------------------------
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(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 int?calculate(TestTarget target, IDictionary <Measure, object> requiredMeasures, CalculationParameters parameters, ScenarioMarketData marketData, ReferenceData refData)
{
int?bar = (int?)requiredMeasures[CASH_FLOWS];
int?baz = (int?)requiredMeasures[PAR_RATE];
return(target.Value * bar + baz);
}
//-------------------------------------------------------------------------
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));
}
//-------------------------------------------------------------------------
//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.cms.CmsTrade 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(CmsTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData)
{
// expand the trade once for all measures and all scenarios
ResolvedCmsTrade resolved = trade.resolve(refData);
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
RatesScenarioMarketData ratesMarketData = ratesLookup.marketDataView(scenarioMarketData);
SwaptionMarketDataLookup swaptionLookup = parameters.getParameter(typeof(SwaptionMarketDataLookup));
SwaptionScenarioMarketData swaptionMarketData = swaptionLookup.marketDataView(scenarioMarketData);
CmsSabrExtrapolationParams cmsParams = parameters.getParameter(typeof(CmsSabrExtrapolationParams));
CmsMeasureCalculations calculations = new CmsMeasureCalculations(cmsParams);
// 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, calculations, ratesMarketData, swaptionMarketData);
}
return(results);
}
//-------------------------------------------------------------------------
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));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ImmutableDefaults private static void applyDefaults(Builder builder)
private static void applyDefaults(Builder builder)
{
builder.parameters(CalculationParameters.empty());
}
//-------------------------------------------------------------------------
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));
}
//-------------------------------------------------------------------------
/// <summary>
/// Combines the parameters with another reporting currency and set of parameters.
/// </summary>
/// <param name="reportingCurrency"> the default reporting currency </param>
/// <param name="defaultParameters"> the default parameters </param>
/// <returns> the combined column </returns>
public Column combineWithDefaults(ReportingCurrency reportingCurrency, CalculationParameters defaultParameters)
{
CalculationParameters combinedParams = parameters.combinedWith(defaultParameters);
return(new Column(name, measure, ReportingCurrency.orElse(reportingCurrency), combinedParams));
}
//-------------------------------------------------------------------------
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));
}
/// <summary>
/// Sets the calculation parameters that apply to this column, used to control the how the calculation is performed.
/// <para>
/// The parameters from <seealso cref="CalculationRules"/> and {@code Column} are combined.
/// If a parameter is defined here and in the rules with the same
/// <seealso cref="CalculationParameter#queryType() query type"/>, then the column parameter takes precedence.
/// </para>
/// <para>
/// When building, these will default to be empty.
/// </para>
/// </summary>
/// <param name="parameters"> the new value </param>
/// <returns> this, for chaining, not null </returns>
public Builder parameters(CalculationParameters parameters)
{
this.parameters_Renamed = parameters;
return(this);
}
//-------------------------------------------------------------------------
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));
}
//-------------------------------------------------------------------------
public virtual FunctionRequirements requirements(SecurityTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
Security security = refData.getValue(trade.SecurityId);
QuoteId id = QuoteId.of(trade.SecurityId.StandardId);
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.of(id)).outputCurrencies(security.Currency).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);
}
//-------------------------------------------------------------------------
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));
}
/// <summary>
/// Obtains an instance that will calculate the specified measure, converting to the specified currency.
/// <para>
/// The column name will be the same as the name of the measure.
///
/// </para>
/// </summary>
/// <param name="measure"> the measure to be calculated </param>
/// <param name="currency"> the currency to convert to </param>
/// <returns> a column with the specified measure </returns>
public static Column of(Measure measure, Currency currency)
{
ColumnName name = ColumnName.of(measure);
return(new Column(name, measure, ReportingCurrency.of(currency), CalculationParameters.empty()));
}
//-------------------------------------------------------------------------
public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
// extract data from product
IborFuture product = target.Product;
QuoteId quoteId = QuoteId.of(product.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE);
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);
//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());
}
/// <summary>
/// Obtains an instance that will calculate the specified measure, defining the column name and parameters.
/// <para>
/// The specified calculation parameters take precedence over those in <seealso cref="CalculationRules"/>,
/// with the combined set being used for the column.
/// Currency conversion is controlled by the reporting currency in {@code CalculationRules}.
///
/// </para>
/// </summary>
/// <param name="measure"> the measure to be calculated </param>
/// <param name="columnName"> the column name </param>
/// <param name="parameters"> the parameters that control the calculation, may be empty </param>
/// <returns> a column with the specified measure, column name and reporting currency </returns>
public static Column of(Measure measure, string columnName, params CalculationParameter[] parameters)
{
ColumnName name = ColumnName.of(columnName);
return(new Column(name, measure, null, CalculationParameters.of(parameters)));
}
//-------------------------------------------------------------------------
//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
ResolvedBillTrade resolved = target.resolve(refData);
// use lookup to query market data
LegalEntityDiscountingMarketDataLookup lookup = parameters.getParameter(typeof(LegalEntityDiscountingMarketDataLookup));
LegalEntityDiscountingScenarioMarketData marketData = lookup.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, marketData);
}
return(results);
}
/// <summary>
/// Obtains an instance that will calculate the specified measure, converting to the specified currency,
/// defining the column name and parameters.
/// <para>
/// The specified calculation parameters take precedence over those in <seealso cref="CalculationRules"/>,
/// with the combined set being used for the column.
///
/// </para>
/// </summary>
/// <param name="measure"> the measure to be calculated </param>
/// <param name="columnName"> the column name </param>
/// <param name="currency"> the currency to convert to </param>
/// <param name="parameters"> the parameters that control the calculation, may be empty </param>
/// <returns> a column with the specified measure, column name and reporting currency </returns>
public static Column of(Measure measure, string columnName, Currency currency, params CalculationParameter[] parameters)
{
ColumnName name = ColumnName.of(columnName);
return(new Column(name, measure, ReportingCurrency.of(currency), CalculationParameters.of(parameters)));
}
//-------------------------------------------------------------------------
//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.GenericSecurityPosition position, 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(GenericSecurityPosition position, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData)
{
// 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, position, scenarioMarketData);
}
return(results);
}
//-------------------------------------------------------------------------
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));
}
