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