// calculate one measure //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: private com.opengamma.strata.collect.result.Result<?> calculate(com.opengamma.strata.calc.Measure measure, com.opengamma.strata.product.credit.ResolvedCdsIndexTrade trade, CreditRatesScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData) private Result <object> calculate(Measure measure, ResolvedCdsIndexTrade trade, CreditRatesScenarioMarketData marketData, ReferenceData refData) { SingleMeasureCalculation calculator = CALCULATORS.get(measure); if (calculator == null) { return(Result.failure(FailureReason.UNSUPPORTED, "Unsupported measure for CdsIndexTrade: {}", measure)); } return(Result.of(() => calculator(trade, marketData, refData))); }
/// <summary> /// Computes parallel CS01 for CDS index using a single credit curve. /// <para> /// This is coherent to the pricer <seealso cref="IsdaHomogenousCdsIndexTradePricer"/>. /// The relevant credit curve must be stored in {@code RatesProvider}. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="bucketCdsIndex"> the CDS index bucket </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="refData"> the reference data </param> /// <returns> the parallel CS01 </returns> public virtual CurrencyAmount parallelCs01(ResolvedCdsIndexTrade trade, IList <ResolvedCdsIndexTrade> bucketCdsIndex, CreditRatesProvider ratesProvider, ReferenceData refData) { ResolvedCdsTrade cdsTrade = trade.toSingleNameCds(); //JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter: IList <ResolvedCdsTrade> bucketCds = bucketCdsIndex.Select(ResolvedCdsIndexTrade::toSingleNameCds).ToList(); CurrencyAmount cs01Cds = parallelCs01(cdsTrade, bucketCds, ratesProvider, refData); double indexFactor = getIndexFactor(cdsTrade.Product, ratesProvider); return(cs01Cds.multipliedBy(indexFactor)); }
/// <summary> /// Computes bucketed CS01 for CDS index using a single credit curve. /// <para> /// This is coherent to the pricer <seealso cref="IsdaHomogenousCdsIndexTradePricer"/>. /// The relevant credit curve must be stored in {@code RatesProvider}. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="bucketCdsIndex"> the CDS index bucket </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="refData"> the reference data </param> /// <returns> the bucketed CS01 </returns> public virtual CurrencyParameterSensitivity bucketedCs01(ResolvedCdsIndexTrade trade, IList <ResolvedCdsIndexTrade> bucketCdsIndex, CreditRatesProvider ratesProvider, ReferenceData refData) { ResolvedCdsTrade cdsTrade = trade.toSingleNameCds(); //JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter: IList <ResolvedCdsTrade> bucketCds = bucketCdsIndex.Select(ResolvedCdsIndexTrade::toSingleNameCds).ToList(); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <ResolvedTradeParameterMetadata> metadata = bucketCdsIndex.Select(t => ResolvedTradeParameterMetadata.of(t, t.Product.ProtectionEndDate.ToString())).collect(Guavate.toImmutableList()); CurrencyParameterSensitivity bucketedCs01 = this.bucketedCs01(cdsTrade, bucketCds, metadata, ratesProvider, refData); double indexFactor = getIndexFactor(cdsTrade.Product, ratesProvider); return(bucketedCs01.multipliedBy(indexFactor)); }
//------------------------------------------------------------------------- //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.credit.CdsIndexTrade 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(CdsIndexTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData) { // resolve the trade once for all measures and all scenarios ResolvedCdsIndexTrade resolved = trade.resolve(refData); // use lookup to query market data CreditRatesMarketDataLookup ledLookup = parameters.getParameter(typeof(CreditRatesMarketDataLookup)); CreditRatesScenarioMarketData marketData = 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, marketData, refData); } return(results); }
/// <summary> /// Computes bucketed CS01 for CDS index using a single credit curve. /// <para> /// This is coherent to the pricer <seealso cref="IsdaHomogenousCdsIndexTradePricer"/>. /// The relevant credit curve must be stored in {@code RatesProvider}. /// </para> /// <para> /// The CDS index trades used in the curve calibration are reused as bucket CDS index by this method. /// Thus the credit curve must store <seealso cref="ResolvedTradeParameterMetadata"/>. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="refData"> the reference data </param> /// <returns> the bucketed CS01 </returns> public virtual CurrencyParameterSensitivity bucketedCs01(ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { IList <ResolvedCdsIndexTrade> bucketCdsIndex = getBucketCdsIndex(trade.Product, ratesProvider); return(bucketedCs01(trade, bucketCdsIndex, ratesProvider, refData)); }
//------------------------------------------------------------------------- /// <summary> /// Computes parallel CS01 for CDS index using a single credit curve. /// <para> /// This is coherent to the pricer <seealso cref="IsdaHomogenousCdsIndexTradePricer"/>. /// The relevant credit curve must be stored in {@code RatesProvider}. /// </para> /// <para> /// The CDS index trades used in the curve calibration are reused as bucket CDS index by this method. /// Thus the credit curve must store <seealso cref="ResolvedTradeParameterMetadata"/>. /// /// </para> /// </summary> /// <param name="trade"> the trade </param> /// <param name="ratesProvider"> the rates provider </param> /// <param name="refData"> the reference data </param> /// <returns> the parallel CS01 </returns> public virtual CurrencyAmount parallelCs01(ResolvedCdsIndexTrade trade, CreditRatesProvider ratesProvider, ReferenceData refData) { IList <ResolvedCdsIndexTrade> bucketCdsIndex = getBucketCdsIndex(trade.Product, ratesProvider); return(parallelCs01(trade, bucketCdsIndex, ratesProvider, refData)); }