//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
IborFutureOptionTradeCalculationFunction <IborFutureOptionTrade> function = IborFutureOptionTradeCalculationFunction.TRADE;
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsOnly(CURRENCY);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(DISCOUNT_CURVE_ID, FORWARD_CURVE_ID, VOL_ID, QUOTE_ID_OPTION));
assertThat(reqs.TimeSeriesRequirements).isEqualTo(ImmutableSet.of(IndexQuoteId.of(INDEX)));
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(CURRENCY);
}
//-------------------------------------------------------------------------
public FunctionRequirements requirements(ISet <CurrencyPair> currencyPairs)
{
foreach (CurrencyPair currencyPair in currencyPairs)
{
if (!volatilityIds.Keys.Contains(currencyPair))
{
throw new System.ArgumentException(msgPairNotFound(currencyPair));
}
}
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.copyOf(volatilityIds.values())).build());
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
SecurityPositionCalculationFunction function = new SecurityPositionCalculationFunction();
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(POSITION, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsOnly(CURRENCY);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(QuoteId.of(SEC_ID.StandardId)));
assertThat(reqs.TimeSeriesRequirements).Empty;
assertThat(function.naturalCurrency(POSITION, REF_DATA)).isEqualTo(CURRENCY);
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
FxSwapTradeCalculationFunction function = new FxSwapTradeCalculationFunction();
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsExactly(GBP, USD);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(DISCOUNT_CURVE_GBP_ID, DISCOUNT_CURVE_USD_ID));
assertThat(reqs.TimeSeriesRequirements).Empty;
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(GBP);
}
//-------------------------------------------------------------------------
public FunctionRequirements requirements(ISet <IborIndex> indices)
{
foreach (Index index in indices)
{
if (!volatilityIds.Keys.Contains(index))
{
throw new System.ArgumentException(msgIndexNotFound(index));
}
}
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.copyOf(volatilityIds.values())).build());
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
BulletPaymentTradeCalculationFunction function = new BulletPaymentTradeCalculationFunction();
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsOnly(CURRENCY);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(DISCOUNT_CURVE_ID));
assertThat(reqs.TimeSeriesRequirements).isEqualTo(ImmutableSet.of());
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(CURRENCY);
}
//-------------------------------------------------------------------------
public virtual void test_requirementsAndCurrency()
{
FixedCouponBondTradeCalculationFunction <FixedCouponBondTrade> function = FixedCouponBondTradeCalculationFunction.TRADE;
ISet <Measure> measures = function.supportedMeasures();
FunctionRequirements reqs = function.requirements(TRADE, measures, PARAMS, REF_DATA);
assertThat(reqs.OutputCurrencies).containsOnly(CURRENCY);
assertThat(reqs.ValueRequirements).isEqualTo(ImmutableSet.of(REPO_CURVE_ID, ISSUER_CURVE_ID));
assertThat(reqs.TimeSeriesRequirements).isEqualTo(ImmutableSet.of());
assertThat(function.naturalCurrency(TRADE, REF_DATA)).isEqualTo(CURRENCY);
}
public virtual void test_map()
{
assertEquals(LOOKUP.queryType(), typeof(CreditRatesMarketDataLookup));
assertEquals(LOOKUP_WITH_SOURCE.requirements(ISSUER_A, USD), FunctionRequirements.builder().observableSource(OBS_SOURCE).valueRequirements(CC_A_USD, DC_USD, RC_A).outputCurrencies(USD).build());
assertEquals(LOOKUP_WITH_SOURCE.requirements(ISSUER_A, GBP), FunctionRequirements.builder().observableSource(OBS_SOURCE).valueRequirements(CC_A_GBP, DC_GBP, RC_A).outputCurrencies(GBP).build());
assertEquals(LOOKUP_WITH_SOURCE.requirements(ISSUER_B, GBP), FunctionRequirements.builder().observableSource(OBS_SOURCE).valueRequirements(CC_B_GBP, DC_GBP, RC_B).outputCurrencies(GBP).build());
assertEquals(LOOKUP.requirements(ISSUER_A, USD), FunctionRequirements.builder().valueRequirements(CC_A_USD, DC_USD, RC_A).outputCurrencies(USD).build());
assertEquals(LOOKUP.requirements(ISSUER_A, GBP), FunctionRequirements.builder().valueRequirements(CC_A_GBP, DC_GBP, RC_A).outputCurrencies(GBP).build());
assertEquals(LOOKUP.requirements(ISSUER_B, GBP), FunctionRequirements.builder().valueRequirements(CC_B_GBP, DC_GBP, RC_B).outputCurrencies(GBP).build());
assertThrowsIllegalArg(() => LOOKUP.requirements(ISSUER_A, EUR));
assertThrowsIllegalArg(() => LOOKUP.requirements(ISSUER_C, USD));
assertEquals(LOOKUP.creditRatesProvider(MOCK_MARKET_DATA), DefaultLookupCreditRatesProvider.of((DefaultCreditRatesMarketDataLookup)LOOKUP, MOCK_MARKET_DATA));
}
//-------------------------------------------------------------------------
public FunctionRequirements requirements(ISet <SecurityId> securityIds)
{
ISet <BondFutureVolatilitiesId> volIds = new HashSet <BondFutureVolatilitiesId>();
foreach (SecurityId securityId in securityIds)
{
if (!volatilityIds.Keys.Contains(securityId))
{
throw new System.ArgumentException(msgSecurityNotFound(securityId));
}
volIds.Add(volatilityIds.get(securityId));
}
return(FunctionRequirements.builder().valueRequirements(volIds).build());
}
//-------------------------------------------------------------------------
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 FunctionRequirements requirements(ISet <IborIndex> indices)
{
ISet <IborFutureOptionVolatilitiesId> volIds = new HashSet <IborFutureOptionVolatilitiesId>();
foreach (Index index in indices)
{
if (!volatilityIds.Keys.Contains(index))
{
throw new System.ArgumentException(msgIndexNotFound(index));
}
volIds.Add(volatilityIds.get(index));
}
return(FunctionRequirements.builder().valueRequirements(volIds).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(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
OvernightFuture product = target.Product;
QuoteId quoteId = QuoteId.of(target.Product.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE);
OvernightIndex index = product.Index;
// use lookup to build requirements
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
FunctionRequirements ratesReqs = ratesLookup.requirements(ImmutableSet.of(), ImmutableSet.of(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());
}
//-------------------------------------------------------------------------
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(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 FunctionRequirements requirements(LegalEntityId issuerId, Currency currency)
{
// repo
RepoGroup repoKey = repoCurveGroups.get(issuerId);
if (repoKey == null)
{
throw new System.ArgumentException(Messages.format("Legal entity discounting lookup has no repo curve defined for '{}'", issuerId));
}
CurveId repoCurveId = repoCurves.get(Pair.of(repoKey, currency));
if (repoCurveId == null)
{
throw new System.ArgumentException(Messages.format("Legal entity discounting lookup has no repo curve defined for '{}'", issuerId));
}
// result
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.of(repoCurveId)).outputCurrencies(currency).observableSource(observableSource).build());
}
//-------------------------------------------------------------------------
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 FunctionRequirements requirements(StandardId legalEntityId, Currency currency)
{
CurveId creditCurveId = creditCurveIds.get(Pair.of(legalEntityId, currency));
if (creditCurveId == null)
{
throw new System.ArgumentException(Messages.format("Credit rates lookup has no credit curve defined for '{}' and '{}'", legalEntityId, currency));
}
CurveId discountCurveId = discountCurveIds.get(currency);
if (discountCurveId == null)
{
throw new System.ArgumentException(Messages.format("Credit rates lookup has no discount curve defined for '{}'", currency));
}
CurveId recoveryRateCurveId = recoveryRateCurveIds.get(legalEntityId);
if (recoveryRateCurveId == null)
{
throw new System.ArgumentException(Messages.format("Credit rates lookup has no recovery rate curve defined for '{}'", legalEntityId));
}
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.of(creditCurveId, discountCurveId, recoveryRateCurveId)).outputCurrencies(currency).observableSource(observableSource).build());
}
//-------------------------------------------------------------------------
public virtual void test_of_map()
{
ImmutableMap <Currency, CurveId> discounts = ImmutableMap.of(USD, CURVE_ID_DSC);
ImmutableMap <Index, CurveId> forwards = ImmutableMap.of(USD_LIBOR_3M, CURVE_ID_FWD);
RatesMarketDataLookup test = RatesMarketDataLookup.of(discounts, forwards);
assertEquals(test.queryType(), typeof(RatesMarketDataLookup));
assertEquals(test.DiscountCurrencies, ImmutableSet.of(USD));
assertEquals(test.getDiscountMarketDataIds(USD), ImmutableSet.of(CURVE_ID_DSC));
assertEquals(test.ForwardIndices, ImmutableSet.of(USD_LIBOR_3M));
assertEquals(test.getForwardMarketDataIds(USD_LIBOR_3M), ImmutableSet.of(CURVE_ID_FWD));
assertThrowsIllegalArg(() => test.getDiscountMarketDataIds(GBP));
assertThrowsIllegalArg(() => test.getForwardMarketDataIds(GBP_LIBOR_3M));
assertEquals(test.ObservableSource, ObservableSource.NONE);
assertEquals(test.FxRateLookup, FxRateLookup.ofRates());
assertEquals(test.requirements(USD), FunctionRequirements.builder().valueRequirements(CURVE_ID_DSC).outputCurrencies(USD).build());
assertEquals(test.requirements(USD, USD_LIBOR_3M), FunctionRequirements.builder().valueRequirements(CURVE_ID_DSC, CURVE_ID_FWD).timeSeriesRequirements(IndexQuoteId.of(USD_LIBOR_3M)).outputCurrencies(USD).build());
assertEquals(test.requirements(ImmutableSet.of(USD), ImmutableSet.of(USD_LIBOR_3M)), FunctionRequirements.builder().valueRequirements(CURVE_ID_DSC, CURVE_ID_FWD).timeSeriesRequirements(IndexQuoteId.of(USD_LIBOR_3M)).outputCurrencies(USD).build());
assertThrowsIllegalArg(() => test.requirements(ImmutableSet.of(USD), ImmutableSet.of(GBP_LIBOR_3M)));
assertEquals(test.ratesProvider(MOCK_MARKET_DATA), DefaultLookupRatesProvider.of((DefaultRatesMarketDataLookup)test, MOCK_MARKET_DATA));
}
//-------------------------------------------------------------------------
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());
}
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());
}
