private CrossGammaParameterSensitivity computeGammaForCurve(CurveName curveName, Curve curve, Currency sensitivityCurrency, System.Func <Curve, ImmutableLegalEntityDiscountingProvider> ratesProviderFn, System.Func <ImmutableLegalEntityDiscountingProvider, CurrencyParameterSensitivities> sensitivitiesFn) { System.Func <DoubleArray, DoubleArray> function = (DoubleArray t) => { Curve newCurve = curve.withPerturbation((i, v, m) => t.get(i)); ImmutableLegalEntityDiscountingProvider newRates = ratesProviderFn(newCurve); CurrencyParameterSensitivities sensiMulti = sensitivitiesFn(newRates); return(sensiMulti.getSensitivity(curveName, sensitivityCurrency).Sensitivity); }; int nParams = curve.ParameterCount; DoubleMatrix sensi = fd.differentiate(function).apply(DoubleArray.of(nParams, n => curve.getParameter(n))); IList <ParameterMetadata> metadata = IntStream.range(0, nParams).mapToObj(i => curve.getParameterMetadata(i)).collect(toImmutableList()); return(CrossGammaParameterSensitivity.of(curveName, metadata, sensitivityCurrency, sensi)); }
//------------------------------------------------------------------------- public virtual void test_of() { ZeroRateDiscountFactors test = ZeroRateDiscountFactors.of(GBP, DATE_VAL, CURVE); assertEquals(test.Currency, GBP); assertEquals(test.ValuationDate, DATE_VAL); assertEquals(test.Curve, CURVE); assertEquals(test.ParameterCount, CURVE.ParameterCount); assertEquals(test.getParameter(0), CURVE.getParameter(0)); assertEquals(test.getParameterMetadata(0), CURVE.getParameterMetadata(0)); assertEquals(test.withParameter(0, 1d).Curve, CURVE.withParameter(0, 1d)); assertEquals(test.withPerturbation((i, v, m) => v + 1d).Curve, CURVE.withPerturbation((i, v, m) => v + 1d)); assertEquals(test.findData(CURVE.Name), CURVE); assertEquals(test.findData(CurveName.of("Rubbish")), null); }
//------------------------------------------------------------------------- private static void parseCurveMaps(CharSource groupsCharSource, IDictionary <CurveGroupName, IDictionary <Pair <RepoGroup, Currency>, CurveName> > repoGroups, IDictionary <CurveGroupName, IDictionary <Pair <LegalEntityGroup, Currency>, CurveName> > legalEntityGroups) { CsvFile csv = CsvFile.of(groupsCharSource, true); foreach (CsvRow row in csv.rows()) { string curveGroupStr = row.getField(GROUPS_NAME); string curveTypeStr = row.getField(GROUPS_CURVE_TYPE); string referenceStr = row.getField(GROUPS_REFERENCE); string currencyStr = row.getField(GROUPS_CURRENCY); string curveNameStr = row.getField(GROUPS_CURVE_NAME); CurveName curveName = CurveName.of(curveNameStr); createKey(curveName, CurveGroupName.of(curveGroupStr), curveTypeStr, referenceStr, currencyStr, repoGroups, legalEntityGroups); } }
//------------------------------------------------------------------------- internal static ScenarioMarketData marketData(CurveName curveName) { DoubleMatrix jacobian = DoubleMatrix.ofUnsafe(new double[][] { new double[] { 0.985d, 0.01d, 0d }, new double[] { 0.01d, 0.98d, 0.01d }, new double[] { 0.005d, 0.01d, 0.99d } }); JacobianCalibrationMatrix jcm = JacobianCalibrationMatrix.of(ImmutableList.of(CurveParameterSize.of(curveName, 3)), jacobian); DoubleArray time = DoubleArray.of(0.1, 0.25, 0.5d); DoubleArray rate = DoubleArray.of(0.01, 0.015, 0.008d); Curve curve = InterpolatedNodalCurve.of(Curves.zeroRates(curveName, ACT_360).withInfo(CurveInfoType.JACOBIAN, jcm), time, rate, NATURAL_SPLINE); TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(FORWARD_CURVE_ID, curve, QUOTE_KEY, MARKET_PRICE), ImmutableMap.of()); return(md); }
// build the curves private static IList <CurveDefinition> buildCurveDefinition(IDictionary <CurveName, LoadedCurveSettings> settingsMap, IDictionary <CurveName, IList <CurveNode> > allNodes) { ImmutableList.Builder <CurveDefinition> results = ImmutableList.builder(); foreach (KeyValuePair <CurveName, IList <CurveNode> > entry in allNodes.SetOfKeyValuePairs()) { CurveName name = entry.Key; LoadedCurveSettings settings = settingsMap[name]; if (settings == null) { throw new System.ArgumentException(Messages.format("Missing settings for curve: {}", name)); } results.add(settings.createCurveDefinition(entry.Value)); } return(results.build()); }
private LoadedCurveSettings(CurveName curveName, ValueType xValueType, ValueType yValueType, DayCount dayCount, CurveInterpolator interpolator, CurveExtrapolator extrapolatorLeft, CurveExtrapolator extrapolatorRight) { JodaBeanUtils.notNull(curveName, "curveName"); JodaBeanUtils.notNull(xValueType, "xValueType"); JodaBeanUtils.notNull(yValueType, "yValueType"); JodaBeanUtils.notNull(dayCount, "dayCount"); JodaBeanUtils.notNull(interpolator, "interpolator"); JodaBeanUtils.notNull(extrapolatorLeft, "extrapolatorLeft"); JodaBeanUtils.notNull(extrapolatorRight, "extrapolatorRight"); this.curveName = curveName; this.xValueType = xValueType; this.yValueType = yValueType; this.dayCount = dayCount; this.interpolator = interpolator; this.extrapolatorLeft = extrapolatorLeft; this.extrapolatorRight = extrapolatorRight; }
public virtual void test_of_constant_interface() { IsdaCreditDiscountFactors test = (IsdaCreditDiscountFactors)CreditDiscountFactors.of(USD, VALUATION, CONST_CURVE); assertEquals(test.Currency, USD); assertEquals(test.Curve, CONST_CURVE); assertEquals(test.DayCount, ACT_365L); assertEquals(test.ParameterCount, 1); assertEquals(test.getParameter(0), RATE_SINGLE); assertEquals(test.ParameterKeys, DoubleArray.of(TIME_SINGLE)); assertEquals(test.getParameterMetadata(0), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME_SINGLE)); assertEquals(test.ValuationDate, VALUATION); assertEquals(test.findData(CONST_CURVE.Name), CONST_CURVE); assertEquals(test.findData(CurveName.of("Rubbish")), null); assertEquals(test.toDiscountFactors(), ZeroRateDiscountFactors.of(USD, VALUATION, CONST_CURVE)); assertEquals(test.IsdaCompliant, true); }
//------------------------------------------------------------------------- /// <summary> /// Parses the seasonality definition CSV file. /// </summary> /// <param name="charSource"> the seasonality CSV character source </param> /// <returns> the map of seasonality definitions </returns> public static IDictionary <CurveName, SeasonalityDefinition> parseSeasonalityDefinitions(CharSource charSource) { ImmutableMap.Builder <CurveName, SeasonalityDefinition> builder = ImmutableMap.builder(); CsvFile csv = CsvFile.of(charSource, true); foreach (CsvRow row in csv.rows()) { string curveNameStr = row.getField(CURVE_NAME); string shiftTypeStr = row.getField(SHIFT_TYPE); DoubleArray values = DoubleArray.of(12, i => double.Parse(row.getField(MONTH_PAIRS.get(i)))); CurveName curveName = CurveName.of(curveNameStr); ShiftType shiftType = ShiftType.valueOf(shiftTypeStr.ToUpper(Locale.ENGLISH)); builder.put(curveName, SeasonalityDefinition.of(values, shiftType)); } return(builder.build()); }
public virtual void test_bondDiscountingProvider() { LocalDate valDate = LocalDate.of(2015, 6, 30); Curve ccAUsd = ConstantNodalCurve.of(Curves.zeroRates(CC_A_USD.CurveName, ACT_365F), 0.5d, 1.5d); Curve ccBGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_B_GBP.CurveName, ACT_365F), 0.5d, 2d); Curve ccAGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_A_GBP.CurveName, ACT_365F), 0.5d, 3d); Curve dcGbp = ConstantNodalCurve.of(Curves.zeroRates(DC_GBP.CurveName, ACT_365F), 0.5d, 0.1d); Curve dcUsd = ConstantNodalCurve.of(Curves.zeroRates(DC_USD.CurveName, ACT_365F), 0.5d, 0.05d); Curve rcA = ConstantCurve.of(Curves.recoveryRates(RC_A.CurveName, ACT_365F), 0.5d); Curve rcB = ConstantCurve.of(Curves.recoveryRates(RC_B.CurveName, ACT_365F), 0.4234d); IDictionary <CurveId, Curve> curveMap = new Dictionary <CurveId, Curve>(); curveMap[CC_A_USD] = ccAUsd; curveMap[CC_B_GBP] = ccBGbp; curveMap[CC_A_GBP] = ccAGbp; curveMap[DC_USD] = dcUsd; curveMap[DC_GBP] = dcGbp; curveMap[RC_A] = rcA; curveMap[RC_B] = rcB; MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.copyOf(curveMap)); CreditRatesProvider provider = LOOKUP_WITH_SOURCE.creditRatesProvider(md); assertEquals(provider.ValuationDate, valDate); assertEquals(provider.findData(CC_A_USD.CurveName), ccAUsd); assertEquals(provider.findData(DC_USD.CurveName), dcUsd); assertEquals(provider.findData(RC_B.CurveName), rcB); assertEquals(provider.findData(CurveName.of("Rubbish")), null); // check credit curve LegalEntitySurvivalProbabilities cc = provider.survivalProbabilities(ISSUER_A, GBP); IsdaCreditDiscountFactors ccUnder = (IsdaCreditDiscountFactors)cc.SurvivalProbabilities; assertEquals(ccUnder.Curve.Name, ccAGbp.Name); assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_B, USD)); assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_C, USD)); // check discount curve IsdaCreditDiscountFactors dc = (IsdaCreditDiscountFactors)provider.discountFactors(USD); assertEquals(dc.Curve.Name, dcUsd.Name); assertThrowsRuntime(() => provider.discountFactors(EUR)); // check recovery rate curve ConstantRecoveryRates rc = (ConstantRecoveryRates)provider.recoveryRates(ISSUER_B); assertEquals(rc.RecoveryRate, rcB.getParameter(0)); assertThrowsRuntime(() => provider.recoveryRates(ISSUER_C)); }
public MarketDataBox <RatesCurveInputs> build(RatesCurveInputsId id, MarketDataConfig marketDataConfig, ScenarioMarketData marketData, ReferenceData refData) { CurveGroupName groupName = id.CurveGroupName; CurveName curveName = id.CurveName; RatesCurveGroupDefinition groupDefn = marketDataConfig.get(typeof(RatesCurveGroupDefinition), groupName); Optional <CurveDefinition> optionalDefinition = groupDefn.findCurveDefinition(id.CurveName); if (!optionalDefinition.Present) { throw new System.ArgumentException(Messages.format("No curve named '{}' found in group '{}'", curveName, groupName)); } CurveDefinition configuredDefn = optionalDefinition.get(); // determine market data needs MarketDataBox <LocalDate> valuationDates = marketData.ValuationDate; bool multipleValuationDates = valuationDates.ScenarioValue; // curve definition can vary for each valuation date if (multipleValuationDates) { IList <CurveDefinition> curveDefns = IntStream.range(0, valuationDates.ScenarioCount).mapToObj(valuationDates.getValue).map((LocalDate valDate) => configuredDefn.filtered(valDate, refData)).collect(toImmutableList()); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(curveDefns); ISet <MarketDataId <object> > requirements = nodeRequirements(curveDefns); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k))); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k))); return(buildMultipleCurveInputs(MarketDataBox.ofScenarioValues(curveDefns), marketDataValues, valuationDates, refData)); } // only one valuation date LocalDate valuationDate = valuationDates.getValue(0); CurveDefinition filteredDefn = configuredDefn.filtered(valuationDate, refData); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Set<com.opengamma.strata.data.MarketDataId<?>> requirements = nodeRequirements(com.google.common.collect.ImmutableList.of(filteredDefn)); ISet <MarketDataId <object> > requirements = nodeRequirements(ImmutableList.of(filteredDefn)); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, com.opengamma.strata.data.scenario.MarketDataBox<?>> marketDataValues = requirements.stream().collect(toImmutableMap(k -> k, k -> marketData.getValue(k))); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IDictionary <MarketDataId <object>, MarketDataBox <object> > marketDataValues = requirements.collect(toImmutableMap(k => k, k => marketData.getValue(k))); // Do any of the inputs contain values for multiple scenarios, or do they contain 1 value each? bool multipleInputValues = marketDataValues.Values.Any(MarketDataBox.isScenarioValue); return(multipleInputValues || multipleValuationDates?buildMultipleCurveInputs(MarketDataBox.ofSingleValue(filteredDefn), marketDataValues, valuationDates, refData) : buildSingleCurveInputs(filteredDefn, marketDataValues, valuationDate, refData)); }
public virtual void test_builder_tenors() { CurveName curveName = CurveName.of("GBP"); CurrencyParameterSensitivity sens1Y = CurrencyParameterSensitivity.of(curveName, ImmutableList.of(TENOR_MD_1Y), GBP, DoubleArray.of(3)); CurveSensitivities test = CurveSensitivities.builder(PortfolioItemInfo.empty()).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1M, 4).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1W, 1).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1Y, 2).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1W, 2).add(ZERO_RATE_DELTA, sens1Y).build(); assertEquals(test.Info, PortfolioItemInfo.empty()); assertEquals(test.TypedSensitivities.size(), 1); CurrencyParameterSensitivities sens = test.getTypedSensitivity(ZERO_RATE_DELTA); assertEquals(sens.Sensitivities.size(), 1); CurrencyParameterSensitivity singleSens = sens.getSensitivity(curveName, GBP); assertEquals(singleSens.Sensitivity, DoubleArray.of(3, 4, 5)); assertEquals(singleSens.getParameterMetadata(0), TENOR_MD_1W); assertEquals(singleSens.getParameterMetadata(1), TENOR_MD_1M); assertEquals(singleSens.getParameterMetadata(2), TENOR_MD_1Y); }
//------------------------------------------------------------------------- /// <summary> /// Parses the curve groups definition CSV file. /// <para> /// The list of <seealso cref="NodalCurveDefinition"/> will be empty in the resulting definition. /// /// </para> /// </summary> /// <param name="groupsCharSource"> the curve groups CSV character source </param> /// <returns> the list of definitions </returns> public static IList <RatesCurveGroupDefinition> parseCurveGroupDefinitions(CharSource groupsCharSource) { IDictionary <CurveName, ISet <GroupAndReference> > curveGroups = new LinkedHashMap <CurveName, ISet <GroupAndReference> >(); CsvFile csv = CsvFile.of(groupsCharSource, true); foreach (CsvRow row in csv.rows()) { string curveGroupStr = row.getField(GROUPS_NAME); string curveTypeStr = row.getField(GROUPS_CURVE_TYPE); string referenceStr = row.getField(GROUPS_REFERENCE); string curveNameStr = row.getField(GROUPS_CURVE_NAME); GroupAndReference gar = createKey(CurveGroupName.of(curveGroupStr), curveTypeStr, referenceStr); CurveName curveName = CurveName.of(curveNameStr); curveGroups.computeIfAbsent(curveName, k => new LinkedHashSet <>()).add(gar); } return(buildCurveGroups(curveGroups)); }
/// <summary> /// Creates a curve group entry for a curve from a list of keys from the same curve group. /// </summary> /// <param name="curveName"> the name of the curve </param> /// <param name="gars"> the group-reference pairs </param> /// <returns> a curve group entry built from the data in the IDs </returns> private static RatesCurveGroupEntry curveGroupEntry(CurveName curveName, IList <GroupAndReference> gars) { ISet <Currency> currencies = new LinkedHashSet <Currency>(); ISet <Index> indices = new LinkedHashSet <Index>(); foreach (GroupAndReference gar in gars) { if (gar.currency != null) { currencies.Add(gar.currency); } else { indices.Add(gar.index); } } return(RatesCurveGroupEntry.builder().curveName(curveName).discountCurrencies(currencies).indices(indices).build()); }
//------------------------------------------------------------------------- // parses the currency as a column or from the reference private static Currency parseCurrency(CsvRow row, CurveName reference) { Optional <string> currencyStr = row.findValue(CURRENCY_HEADER); if (currencyStr.Present) { return(LoaderUtils.parseCurrency(currencyStr.get())); } string referenceStr = reference.Name.ToUpper(Locale.ENGLISH); try { Optional <IborIndex> ibor = IborIndex.extendedEnum().find(referenceStr); if (ibor.Present) { return(ibor.get().Currency); } else { Optional <FloatingRateName> frName = FloatingRateName.extendedEnum().find(referenceStr); if (frName.Present) { return(frName.get().Currency); } else if (referenceStr.Length == 3) { return(Currency.of(referenceStr)); } else if (referenceStr.Length > 3 && referenceStr[3] == '-' || referenceStr[3] == '_') { return(LoaderUtils.parseCurrency(referenceStr.Substring(0, 3))); } else { // drop out to exception } } } catch (Exception) { // drop out to exception } throw new System.ArgumentException("Unable to parse currency from reference, consider adding a 'Currency' column"); }
public virtual void test_ratesProvider() { ImmutableMap <Currency, CurveId> discounts = ImmutableMap.of(USD, CURVE_ID_DSC); ImmutableMap <Index, CurveId> forwards = ImmutableMap.of(USD_FED_FUND, CURVE_ID_DSC, USD_LIBOR_3M, CURVE_ID_FWD, US_CPI_U, CURVE_ID_FWD); RatesMarketDataLookup test = RatesMarketDataLookup.of(discounts, forwards); LocalDate valDate = date(2015, 6, 30); Curve dscCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_DSC.CurveName, ACT_360), 1d); Curve fwdCurve = ConstantCurve.of(Curves.discountFactors(CURVE_ID_FWD.CurveName, ACT_360), 2d); MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.of(CURVE_ID_DSC, dscCurve, CURVE_ID_FWD, fwdCurve)); RatesProvider ratesProvider = test.ratesProvider(md); assertEquals(ratesProvider.ValuationDate, valDate); assertEquals(ratesProvider.findData(CURVE_ID_DSC.CurveName), dscCurve); assertEquals(ratesProvider.findData(CURVE_ID_FWD.CurveName), fwdCurve); assertEquals(ratesProvider.findData(CurveName.of("Rubbish")), null); assertEquals(ratesProvider.IborIndices, ImmutableSet.of(USD_LIBOR_3M)); assertEquals(ratesProvider.OvernightIndices, ImmutableSet.of(USD_FED_FUND)); assertEquals(ratesProvider.PriceIndices, ImmutableSet.of(US_CPI_U)); assertEquals(ratesProvider.TimeSeriesIndices, ImmutableSet.of()); // check discount factors SimpleDiscountFactors df = (SimpleDiscountFactors)ratesProvider.discountFactors(USD); assertEquals(df.Curve.Name, dscCurve.Name); assertThrowsIllegalArg(() => ratesProvider.discountFactors(GBP)); // check Ibor DiscountIborIndexRates ibor = (DiscountIborIndexRates)ratesProvider.iborIndexRates(USD_LIBOR_3M); SimpleDiscountFactors iborDf = (SimpleDiscountFactors)ibor.DiscountFactors; assertEquals(iborDf.Curve.Name, fwdCurve.Name); assertThrowsIllegalArg(() => ratesProvider.iborIndexRates(GBP_LIBOR_3M)); // check Overnight DiscountOvernightIndexRates on = (DiscountOvernightIndexRates)ratesProvider.overnightIndexRates(USD_FED_FUND); SimpleDiscountFactors onDf = (SimpleDiscountFactors)on.DiscountFactors; assertEquals(onDf.Curve.Name, dscCurve.Name); assertThrowsIllegalArg(() => ratesProvider.overnightIndexRates(GBP_SONIA)); // check price curve must be interpolated assertThrowsIllegalArg(() => ratesProvider.priceIndexValues(US_CPI_U)); // to immutable ImmutableRatesProvider expectedImmutable = ImmutableRatesProvider.builder(valDate).fxRateProvider(MarketDataFxRateProvider.of(md)).discountCurve(USD, dscCurve).indexCurve(USD_FED_FUND, dscCurve).indexCurve(USD_LIBOR_3M, fwdCurve).indexCurve(US_CPI_U, fwdCurve).build(); assertEquals(ratesProvider.toImmutableRatesProvider(), expectedImmutable); }
internal static InterpolatedNodalCurveDefinition fraSwapCurveDefinition() { string fra3x6 = "fra3x6"; string fra6x9 = "fra6x9"; string swap1y = "swap1y"; string swap2y = "swap2y"; string swap3y = "swap3y"; FraCurveNode fra3x6Node = CurveTestUtils.fraNode(3, fra3x6); FraCurveNode fra6x9Node = CurveTestUtils.fraNode(6, fra6x9); FixedIborSwapCurveNode swap1yNode = fixedIborSwapNode(Tenor.TENOR_1Y, swap1y); FixedIborSwapCurveNode swap2yNode = fixedIborSwapNode(Tenor.TENOR_2Y, swap2y); FixedIborSwapCurveNode swap3yNode = fixedIborSwapNode(Tenor.TENOR_3Y, swap3y); CurveName curveName = CurveName.of("FRA and Fixed-Float Swap Curve"); IList <CurveNode> nodes = ImmutableList.of(fra3x6Node, fra6x9Node, swap1yNode, swap2yNode, swap3yNode); return(InterpolatedNodalCurveDefinition.builder().name(curveName).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(DayCounts.ACT_ACT_ISDA).nodes(nodes).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).build()); }
private static void createKey(CurveName curveName, CurveGroupName curveGroup, string curveTypeStr, string referenceStr, string currencyStr, IDictionary <CurveGroupName, IDictionary <Pair <RepoGroup, Currency>, CurveName> > repoGroups, IDictionary <CurveGroupName, IDictionary <Pair <LegalEntityGroup, Currency>, CurveName> > legalEntityGroups) { Currency currency = Currency.of(currencyStr); if (REPO.Equals(curveTypeStr.ToLower(Locale.ENGLISH), StringComparison.OrdinalIgnoreCase)) { RepoGroup repoGroup = RepoGroup.of(referenceStr); repoGroups.computeIfAbsent(curveGroup, k => new LinkedHashMap <>()).put(Pair.of(repoGroup, currency), curveName); } else if (ISSUER.Equals(curveTypeStr.ToLower(Locale.ENGLISH), StringComparison.OrdinalIgnoreCase)) { LegalEntityGroup legalEntiryGroup = LegalEntityGroup.of(referenceStr); legalEntityGroups.computeIfAbsent(curveGroup, k => new LinkedHashMap <>()).put(Pair.of(legalEntiryGroup, currency), curveName); } else { throw new System.ArgumentException(Messages.format("Unsupported curve type: {}", curveTypeStr)); } }
public virtual void test_builder_mixCurrency() { CurveName curveName = CurveName.of("WEIRD"); CurveSensitivities test = CurveSensitivities.builder(PortfolioItemInfo.empty()).add(ZERO_RATE_DELTA, curveName, GBP, TENOR_MD_1Y, 1).add(ZERO_RATE_DELTA, curveName, USD, TENOR_MD_1Y, 2).build(); assertEquals(test.Info, PortfolioItemInfo.empty()); assertEquals(test.TypedSensitivities.size(), 1); CurrencyParameterSensitivities sens = test.getTypedSensitivity(ZERO_RATE_DELTA); assertEquals(sens.Sensitivities.size(), 2); CurrencyParameterSensitivity sensGbp = sens.getSensitivity(curveName, GBP); assertEquals(sensGbp.Sensitivity, DoubleArray.of(1)); assertEquals(sensGbp.getParameterMetadata(0), TENOR_MD_1Y); CurrencyParameterSensitivity sensUsd = sens.getSensitivity(curveName, USD); assertEquals(sensUsd.Sensitivity, DoubleArray.of(2)); assertEquals(sensUsd.getParameterMetadata(0), TENOR_MD_1Y); }
public virtual void test_of() { IsdaCreditDiscountFactors test = IsdaCreditDiscountFactors.of(USD, VALUATION, CURVE); assertEquals(test.Currency, USD); assertEquals(test.Curve, CURVE); assertEquals(test.DayCount, ACT_365F); assertEquals(test.ParameterCount, RATE.size()); assertEquals(test.getParameter(3), RATE.get(3)); assertEquals(test.getParameter(1), RATE.get(1)); assertEquals(test.ParameterKeys, TIME); assertEquals(test.getParameterMetadata(4), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME.get(4))); assertEquals(test.getParameterMetadata(6), SimpleCurveParameterMetadata.of(METADATA.XValueType, TIME.get(6))); assertEquals(test.ValuationDate, VALUATION); assertEquals(test.findData(CURVE.Name), CURVE); assertEquals(test.findData(CurveName.of("Rubbish")), null); assertEquals(test.toDiscountFactors(), ZeroRateDiscountFactors.of(USD, VALUATION, CURVE)); assertEquals(test.IsdaCompliant, true); }
//------------------------------------------------------------------------- // parses the file in standard format private void parseStandardFormat(CsvIterator csv, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures) { // loop around all rows, peeking to match batches with the same identifier // no exception catch at this level to avoid infinite loops while (csv.hasNext()) { CsvRow peekedRow = csv.peek(); PortfolioItemInfo info = parseInfo(peekedRow); //JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter: string id = info.Id.map(StandardId::toString).orElse(""); // process in batches, where the ID is the same CurveSensitivitiesBuilder builder = CurveSensitivities.builder(info); IList <CsvRow> batchRows = csv.nextBatch(r => matchId(r, id)); foreach (CsvRow batchRow in batchRows) { try { CurveName reference = CurveName.of(batchRow.getValue(REFERENCE_HEADER)); CurveName resolvedCurveName = resolver.checkCurveName(reference); CurveSensitivitiesType type = CurveSensitivitiesType.of(batchRow.getValue(TYPE_HEADER)); ParameterMetadata metadata = parseMetadata(batchRow, false); Currency currency = parseCurrency(batchRow, reference); string valueStr = batchRow.getField(VALUE_HEADER); if (valueStr.Length > 0) { double value = LoaderUtils.parseDouble(valueStr); builder.add(type, resolvedCurveName, currency, metadata, value); } } catch (System.ArgumentException ex) { failures.Add(FailureItem.of(PARSING, "CSV file could not be parsed at line {}: {}", batchRow.lineNumber(), ex.Message)); } } CurveSensitivities sens = builder.build(); if (!sens.TypedSensitivities.Empty) { parsed.put(sens.Id.map(object.toString).orElse(""), sens); } } }
//------------------------------------------------------------------------- public virtual void duplicateInputDataKeys() { FxSwapTemplate template1 = FxSwapTemplate.of(Period.ofMonths(1), FxSwapConventions.EUR_USD); FxSwapTemplate template2 = FxSwapTemplate.of(Period.ofMonths(2), FxSwapConventions.EUR_USD); QuoteId pointsKey1a = QuoteId.of(StandardId.of("test", "1a")); QuoteId pointsKey1b = QuoteId.of(StandardId.of("test", "1b")); QuoteId pointsKey2a = QuoteId.of(StandardId.of("test", "2a")); QuoteId pointsKey2b = QuoteId.of(StandardId.of("test", "2b")); FxSwapCurveNode node1a = FxSwapCurveNode.of(template1, pointsKey1a); FxSwapCurveNode node1b = FxSwapCurveNode.of(template2, pointsKey1b); FxSwapCurveNode node2 = FxSwapCurveNode.of(template1, pointsKey2a); FxSwapCurveNode node2b = FxSwapCurveNode.of(template2, pointsKey2b); CurveName curveName1 = CurveName.of("curve1"); InterpolatedNodalCurveDefinition curve1 = InterpolatedNodalCurveDefinition.builder().name(curveName1).nodes(node1a, node1b).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(ACT_360).interpolator(CurveInterpolators.LINEAR).extrapolatorLeft(CurveExtrapolators.LINEAR).extrapolatorRight(CurveExtrapolators.LINEAR).build(); CurveName curveName2 = CurveName.of("curve2"); InterpolatedNodalCurveDefinition curve2 = InterpolatedNodalCurveDefinition.builder().name(curveName2).nodes(node2, node2b).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).dayCount(ACT_360).interpolator(CurveInterpolators.LINEAR).extrapolatorLeft(CurveExtrapolators.LINEAR).extrapolatorRight(CurveExtrapolators.LINEAR).build(); CurveGroupName curveGroupName = CurveGroupName.of("group"); RatesCurveGroupDefinition groupDefinition = RatesCurveGroupDefinition.builder().name(curveGroupName).addDiscountCurve(curve1, Currency.EUR).addDiscountCurve(curve2, Currency.USD).build(); RatesCurveGroupMarketDataFunction fn = new RatesCurveGroupMarketDataFunction(); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap1 = com.google.common.collect.ImmutableMap.of(com.opengamma.strata.data.FxRateId.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD), com.opengamma.strata.basics.currency.FxRate.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD, 1.01), pointsKey1a, 0.1d, pointsKey1b, 0.2d); IDictionary <MarketDataId <object>, object> marketDataMap1 = ImmutableMap.of(FxRateId.of(Currency.EUR, Currency.USD), FxRate.of(Currency.EUR, Currency.USD, 1.01), pointsKey1a, 0.1d, pointsKey1b, 0.2d); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap2 = com.google.common.collect.ImmutableMap.of(com.opengamma.strata.data.FxRateId.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD), com.opengamma.strata.basics.currency.FxRate.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD, 1.01), pointsKey2a, 0.1d, pointsKey2b, 0.2d); IDictionary <MarketDataId <object>, object> marketDataMap2 = ImmutableMap.of(FxRateId.of(Currency.EUR, Currency.USD), FxRate.of(Currency.EUR, Currency.USD, 1.01), pointsKey2a, 0.1d, pointsKey2b, 0.2d); RatesCurveInputs curveInputs1 = RatesCurveInputs.of(marketDataMap1, DefaultCurveMetadata.of("curve1")); RatesCurveInputs curveInputs2 = RatesCurveInputs.of(marketDataMap2, DefaultCurveMetadata.of("curve2")); ImmutableScenarioMarketData marketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addValue(RatesCurveInputsId.of(curveGroupName, curveName1, ObservableSource.NONE), curveInputs1).addValue(RatesCurveInputsId.of(curveGroupName, curveName2, ObservableSource.NONE), curveInputs2).build(); fn.buildCurveGroup(groupDefinition, CALIBRATOR, marketData, REF_DATA, ObservableSource.NONE); // This has a duplicate key with a different value which should fail //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> badMarketDataMap = com.google.common.collect.ImmutableMap.of(com.opengamma.strata.data.FxRateId.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD), com.opengamma.strata.basics.currency.FxRate.of(com.opengamma.strata.basics.currency.Currency.EUR, com.opengamma.strata.basics.currency.Currency.USD, 1.02), pointsKey2a, 0.2d); IDictionary <MarketDataId <object>, object> badMarketDataMap = ImmutableMap.of(FxRateId.of(Currency.EUR, Currency.USD), FxRate.of(Currency.EUR, Currency.USD, 1.02), pointsKey2a, 0.2d); RatesCurveInputs badCurveInputs = RatesCurveInputs.of(badMarketDataMap, DefaultCurveMetadata.of("curve2")); ScenarioMarketData badMarketData = ImmutableScenarioMarketData.builder(LocalDate.of(2011, 3, 8)).addValue(RatesCurveInputsId.of(curveGroupName, curveName1, ObservableSource.NONE), curveInputs1).addValue(RatesCurveInputsId.of(curveGroupName, curveName2, ObservableSource.NONE), badCurveInputs).build(); string msg = "Multiple unequal values found for identifier .*\\. Values: .* and .*"; assertThrowsIllegalArg(() => fn.buildCurveGroup(groupDefinition, CALIBRATOR, badMarketData, REF_DATA, ObservableSource.NONE), msg); }
/// <summary> /// Obtains a generator from an existing provider and definition. /// </summary> /// <param name="knownProvider"> the underlying known provider </param> /// <param name="groupDefn"> the curve group definition </param> /// <param name="refData"> the reference data to use </param> /// <returns> the generator </returns> public static ImmutableRatesProviderGenerator of(ImmutableRatesProvider knownProvider, RatesCurveGroupDefinition groupDefn, ReferenceData refData) { IList <CurveDefinition> curveDefns = new List <CurveDefinition>(); IList <CurveMetadata> curveMetadata = new List <CurveMetadata>(); SetMultimap <CurveName, Currency> discountNames = HashMultimap.create(); SetMultimap <CurveName, Index> indexNames = HashMultimap.create(); foreach (CurveDefinition curveDefn in groupDefn.CurveDefinitions) { curveDefns.Add(curveDefn); curveMetadata.Add(curveDefn.metadata(knownProvider.ValuationDate, refData)); CurveName curveName = curveDefn.Name; // A curve group is guaranteed to include an entry for every definition RatesCurveGroupEntry entry = groupDefn.findEntry(curveName).get(); ISet <Currency> ccy = entry.DiscountCurrencies; discountNames.putAll(curveName, ccy); indexNames.putAll(curveName, entry.Indices); } return(new ImmutableRatesProviderGenerator(knownProvider, curveDefns, curveMetadata, discountNames, indexNames)); }
/// <summary> /// Builds a list of curve group definitions from the map of curves and their keys. /// <para> /// The keys specify which curve groups each curve belongs to and how it is used in the group, for example /// as a discount curve for a particular currency or as a forward curve for an index. /// /// </para> /// </summary> /// <param name="garMap"> the map of name to keys </param> /// <returns> a map of curve group name to curve group definition built from the curves </returns> private static ImmutableList <RatesCurveGroupDefinition> buildCurveGroups(IDictionary <CurveName, ISet <GroupAndReference> > garMap) { Multimap <CurveGroupName, RatesCurveGroupEntry> groups = LinkedHashMultimap.create(); foreach (KeyValuePair <CurveName, ISet <GroupAndReference> > entry in garMap.SetOfKeyValuePairs()) { CurveName curveName = entry.Key; ISet <GroupAndReference> curveIds = entry.Value; //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IDictionary <CurveGroupName, IList <GroupAndReference> > idsByGroup = curveIds.collect(groupingBy(p => p.groupName)); foreach (KeyValuePair <CurveGroupName, IList <GroupAndReference> > groupEntry in idsByGroup.SetOfKeyValuePairs()) { CurveGroupName groupName = groupEntry.Key; IList <GroupAndReference> gars = groupEntry.Value; groups.put(groupName, curveGroupEntry(curveName, gars)); } } return(MapStream.of(groups.asMap()).map((name, entry) => RatesCurveGroupDefinition.of(name, entry, ImmutableList.of())).collect(toImmutableList())); }
public virtual void test_getter() { assertEquals(VOLS.ValuationDate, VAL_DATE); assertEquals(VOLS.Index, GBP_LIBOR_3M); assertEquals(VOLS.Surface, SURFACE); assertEquals(VOLS.ParameterCount, TIME.size()); assertEquals(VOLS.findData(CURVE.Name).get(), CURVE); assertEquals(VOLS.findData(SURFACE.Name).get(), SURFACE); assertFalse(VOLS.findData(CurveName.of("foo")).Present); int nParams = VOLS.ParameterCount; double newValue = 152d; for (int i = 0; i < nParams; ++i) { assertEquals(VOLS.getParameter(i), SURFACE.getParameter(i)); assertEquals(VOLS.getParameterMetadata(i), SURFACE.getParameterMetadata(i)); assertEquals(VOLS.withParameter(i, newValue), ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities.of(GBP_LIBOR_3M, VAL_DATE_TIME, SURFACE.withParameter(i, newValue), CURVE)); assertEquals(VOLS.withPerturbation((n, v, m) => 2d * v), ShiftedBlackIborCapletFloorletExpiryStrikeVolatilities.of(GBP_LIBOR_3M, VAL_DATE_TIME, SURFACE.withPerturbation((n, v, m) => 2d * v), CURVE)); } }
private void SetProperties(PricingStructureTypeEnum pricingStructureType, string curveName) { if (pricingStructureType == PricingStructureTypeEnum.RateCurve || pricingStructureType == PricingStructureTypeEnum.RateBasisCurve || pricingStructureType == PricingStructureTypeEnum.ClearedRateCurve || pricingStructureType == PricingStructureTypeEnum.RateSpreadCurve) { var rateCurveId = curveName.Split('-'); var indexTenor = rateCurveId[rateCurveId.Length - 1]; var indexName = rateCurveId[0]; for (var i = 1; i < rateCurveId.Length - 1; i++) { indexName = indexName + '-' + rateCurveId[i]; } ForecastRateIndex = ForecastRateIndexHelper.Parse(indexName, indexTenor); } if (pricingStructureType == PricingStructureTypeEnum.DiscountCurve || pricingStructureType == PricingStructureTypeEnum.RateXccyCurve) { var rateCurveId = CurveName.Split('-'); var subordination = rateCurveId[rateCurveId.Length - 1]; var indexName = rateCurveId[0]; for (var i = 1; i < rateCurveId.Length - 1; i++) { indexName = indexName + '-' + rateCurveId[i]; } CreditInstrumentId = InstrumentIdHelper.Parse(indexName); CreditSeniority = CreditSeniorityHelper.Parse(subordination); } if (pricingStructureType == PricingStructureTypeEnum.InflationCurve) { var rateCurveId = CurveName.Split('-'); var indexTenor = rateCurveId[rateCurveId.Length - 1]; var indexName = rateCurveId[0]; for (var i = 1; i < rateCurveId.Length - 1; i++) { indexName = indexName + '-' + rateCurveId[i]; } ForecastRateIndex = ForecastRateIndexHelper.Parse(indexName, indexTenor); } }
//------------------------------------------------------------------------- public ImmutableRatesProvider generate(DoubleArray parameters, IDictionary <CurveName, JacobianCalibrationMatrix> jacobians, IDictionary <CurveName, DoubleArray> sensitivitiesMarketQuote) { // collect curves for child provider based on existing provider IDictionary <Currency, Curve> discountCurves = new Dictionary <Currency, Curve>(); IDictionary <Index, Curve> indexCurves = new Dictionary <Index, Curve>(); //JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method: discountCurves.putAll(knownProvider.DiscountCurves); //JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method: indexCurves.putAll(knownProvider.IndexCurves); // generate curves from combined parameter array int startIndex = 0; for (int i = 0; i < curveDefinitions.size(); i++) { CurveDefinition curveDefn = curveDefinitions.get(i); CurveMetadata metadata = curveMetadata.get(i); CurveName name = curveDefn.Name; // extract parameters for the child curve int paramCount = curveDefn.ParameterCount; DoubleArray curveParams = parameters.subArray(startIndex, startIndex + paramCount); startIndex += paramCount; // create the child curve CurveMetadata childMetadata = this.childMetadata(metadata, curveDefn, jacobians, sensitivitiesMarketQuote); Curve curve = curveDefn.curve(knownProvider.ValuationDate, childMetadata, curveParams); // put child curve into maps ISet <Currency> currencies = discountCurveNames.get(name); foreach (Currency currency in currencies) { discountCurves[currency] = curve; } ISet <Index> indices = forwardCurveNames.get(name); foreach (Index index in indices) { indexCurves[index] = curve; } } return(knownProvider.toBuilder().discountCurves(discountCurves).indexCurves(indexCurves).build()); }
/// <summary> /// Tests calibration a curve containing FRAs and pricing the curve instruments using the curve. /// </summary> public virtual void roundTripFra() { InterpolatedNodalCurveDefinition curveDefn = CurveTestUtils.fraCurveDefinition(); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <FraCurveNode> nodes = curveDefn.Nodes.Select(typeof(FraCurveNode).cast).collect(toImmutableList()); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<com.opengamma.strata.data.MarketDataId<?>> keys = nodes.stream().map(CurveTestUtils::key).collect(toImmutableList()); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <MarketDataId <object> > keys = nodes.Select(CurveTestUtils.key).collect(toImmutableList()); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, double> inputData = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, double>().put(keys.get(0), 0.003).put(keys.get(1), 0.0033).put(keys.get(2), 0.0037).put(keys.get(3), 0.0054).put(keys.get(4), 0.007).put(keys.get(5), 0.0091).put(keys.get(6), 0.0134).build(); IDictionary <MarketDataId <object>, double> inputData = ImmutableMap.builder <MarketDataId <object>, double>().put(keys[0], 0.003).put(keys[1], 0.0033).put(keys[2], 0.0037).put(keys[3], 0.0054).put(keys[4], 0.007).put(keys[5], 0.0091).put(keys[6], 0.0134).build(); CurveGroupName groupName = CurveGroupName.of("Curve Group"); CurveName curveName = CurveName.of("FRA Curve"); RatesCurveInputs curveInputs = RatesCurveInputs.of(inputData, DefaultCurveMetadata.of(curveName)); RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, IborIndices.USD_LIBOR_3M).build(); RatesCurveGroupMarketDataFunction function = new RatesCurveGroupMarketDataFunction(); LocalDate valuationDate = date(2011, 3, 8); ScenarioMarketData inputMarketData = ImmutableScenarioMarketData.builder(valuationDate).addValue(RatesCurveInputsId.of(groupName, curveName, ObservableSource.NONE), curveInputs).build(); MarketDataBox <RatesCurveGroup> curveGroup = function.buildCurveGroup(groupDefn, CALIBRATOR, inputMarketData, REF_DATA, ObservableSource.NONE); Curve curve = curveGroup.SingleValue.findDiscountCurve(Currency.USD).get(); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, Object> marketDataMap = com.google.common.collect.ImmutableMap.builder<com.opengamma.strata.data.MarketDataId<?>, Object>().putAll(inputData).put(com.opengamma.strata.market.curve.CurveId.of(groupName, curveName), curve).build(); IDictionary <MarketDataId <object>, object> marketDataMap = ImmutableMap.builder <MarketDataId <object>, object>().putAll(inputData).put(CurveId.of(groupName, curveName), curve).build(); MarketData marketData = ImmutableMarketData.of(valuationDate, marketDataMap); TestMarketDataMap scenarioMarketData = new TestMarketDataMap(valuationDate, marketDataMap, ImmutableMap.of()); RatesMarketDataLookup lookup = RatesMarketDataLookup.of(groupDefn); RatesProvider ratesProvider = lookup.ratesProvider(scenarioMarketData.scenario(0)); // The PV should be zero for an instrument used to build the curve nodes.ForEach(node => checkFraPvIsZero(node, ratesProvider, marketData)); }
public void test_write_standard_withDate() { CurveName curve1 = CurveName.of("GBDSC"); CurveName curve2 = CurveName.of("GBFWD"); // listed in reverse order to check ordering CurveSensitivities sens = CurveSensitivities.builder(PortfolioItemInfo.empty().withAttribute(CCP_ATTR, "LCH")).add(ZERO_RATE_GAMMA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_3M), 1).add(ZERO_RATE_GAMMA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_6M), 2).add(ZERO_RATE_DELTA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_3M), 3).add(ZERO_RATE_DELTA, curve2, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_6M), 5).add(ZERO_RATE_DELTA, curve1, Currency.GBP, TenorDateParameterMetadata.of(date(2018, 6, 30), Tenor.TENOR_3M), 2).add(ZERO_RATE_DELTA, curve1, Currency.GBP, TenorParameterMetadata.of(Tenor.TENOR_6M), 4).build(); StringBuilder buf = new StringBuilder(); WRITER_CCP.write(sens, buf); string content = buf.ToString(); string expected = "" + "Reference,Sensitivity Type,Sensitivity Tenor,Sensitivity Date,Currency,Value,CCP\n" + "GBDSC,ZeroRateDelta,3M,2018-06-30,GBP,2.0,LCH\n" + "GBDSC,ZeroRateDelta,6M,,GBP,4.0,LCH\n" + "GBFWD,ZeroRateDelta,3M,,GBP,3.0,LCH\n" + "GBFWD,ZeroRateDelta,6M,,GBP,5.0,LCH\n" + "GBFWD,ZeroRateGamma,3M,,GBP,1.0,LCH\n" + "GBFWD,ZeroRateGamma,6M,,GBP,2.0,LCH\n"; assertEquals(content, expected); }
/// <summary> /// Tests that par rates and ibor index are required for curves. /// </summary> public virtual void requirements() { FraCurveNode node1x4 = CurveTestUtils.fraNode(1, "foo"); FraCurveNode node2x5 = CurveTestUtils.fraNode(2, "foo"); IList <CurveNode> nodes = ImmutableList.of(node1x4, node2x5); CurveGroupName groupName = CurveGroupName.of("Curve Group"); CurveName curveName = CurveName.of("FRA Curve"); ObservableSource obsSource = ObservableSource.of("Vendor"); InterpolatedNodalCurveDefinition curveDefn = InterpolatedNodalCurveDefinition.builder().name(curveName).nodes(nodes).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).build(); RateIndex ibor = IborIndices.USD_LIBOR_3M; RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(groupName).addCurve(curveDefn, Currency.USD, ibor).build(); MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupName, groupDefn).build(); RatesCurveGroupMarketDataFunction function = new RatesCurveGroupMarketDataFunction(); RatesCurveGroupId curveGroupId = RatesCurveGroupId.of(groupName, obsSource); MarketDataRequirements requirements = function.requirements(curveGroupId, marketDataConfig); assertThat(requirements.NonObservables).contains(RatesCurveInputsId.of(groupName, curveName, obsSource)); assertThat(requirements.TimeSeries.contains(IndexQuoteId.of(ibor))); }
//------------------------------------------------------------------------- /// <summary> /// Calculates the notional equivalent from the present value market quote sensitivities. /// <para> /// The notional equivalent is the notional in each instrument used to calibrate the curves to have the same /// sensitivity as the one of the portfolio described by the market quote sensitivities. /// /// </para> /// </summary> /// <param name="marketQuoteSensitivities"> the market quote sensitivities </param> /// <param name="provider"> the rates provider, containing sensitivity information </param> /// <returns> the notionals </returns> public virtual CurrencyParameterSensitivities notionalEquivalent(CurrencyParameterSensitivities marketQuoteSensitivities, RatesProvider provider) { IList <CurrencyParameterSensitivity> equivalentList = new List <CurrencyParameterSensitivity>(); foreach (CurrencyParameterSensitivity s in marketQuoteSensitivities.Sensitivities) { ArgChecker.isTrue(s.MarketDataName is CurveName, "curve name"); CurveName name = (CurveName)s.MarketDataName; Optional <Curve> curveOpt = provider.findData(name); ArgChecker.isTrue(curveOpt.Present, "Curve {} in the sensitiivty is not present in the provider", name); Curve curve = curveOpt.get(); Optional <DoubleArray> pvSensiOpt = curve.Metadata.findInfo(CurveInfoType.PV_SENSITIVITY_TO_MARKET_QUOTE); ArgChecker.isTrue(pvSensiOpt.Present, "Present value sensitivity curve info is required"); DoubleArray pvSensi = pvSensiOpt.get(); double[] notionalArray = new double[pvSensi.size()]; for (int i = 0; i < pvSensi.size(); i++) { notionalArray[i] = s.Sensitivity.get(i) / pvSensi.get(i); } DoubleArray notional = DoubleArray.ofUnsafe(notionalArray); equivalentList.Add(CurrencyParameterSensitivity.of(name, s.ParameterMetadata, s.Currency, notional)); } return(CurrencyParameterSensitivities.of(equivalentList)); }
public GCurve(CurveName Curvename) { name = Curvename.ToString(); minval = double.MinValue; maxval = double.MaxValue; init0 = 0; init1 = 0; Points = new List<KeyValuePair<bool, PointF>>(); }
public GCurve(CurveName Curvename, float Val, int filecount) { name = Curvename.ToString(); minval = double.MinValue; maxval = double.MaxValue; init0 = Val; init1 = Val; SelectedPoint = 0; Points = new List<KeyValuePair<bool, PointF>>(); ResetCurve(filecount); }
public GCurve(CurveName Curvename, double min, double max, float firstVal, float lastVal, int filecount) { name = Curvename.ToString(); minval = min; maxval = max; init0 = firstVal; init1 = lastVal; SelectedPoint = 0; Points = new List<KeyValuePair<bool, PointF>>(); ResetCurve(filecount); }
public GCurve GetCurve(CurveName Name) { GCurve output; Curves.TryGetValue(Name.ToString(), out output); return output; }