public virtual void hard_coded_value_two_curves_one_date() { for (int loopdate = 0; loopdate < SENSITIVITY_DATES.Count - 1; loopdate++) { IList <ParameterMetadata> pmdInput1 = new List <ParameterMetadata>(); pmdInput1.Add(LabelDateParameterMetadata.of(SENSITIVITY_DATES[loopdate], "test")); CurrencyParameterSensitivity s1 = CurrencyParameterSensitivity.of(NAME_1, pmdInput1, CCY_1, DoubleArray.of(SENSITIVITY_AMOUNT)); IList <ParameterMetadata> pmdInput2 = new List <ParameterMetadata>(); pmdInput2.Add(LabelDateParameterMetadata.of(SENSITIVITY_DATES[loopdate + 1], "test")); CurrencyParameterSensitivity s2 = CurrencyParameterSensitivity.of(NAME_2, pmdInput2, CCY_2, DoubleArray.of(SENSITIVITY_AMOUNT)); CurrencyParameterSensitivities sList = CurrencyParameterSensitivities.of(s1, s2); CurrencyParameterSensitivities sTarget = CurveSensitivityUtils.linearRebucketing(sList, TARGET_DATES); assertTrue(sTarget.Sensitivities.size() == 2); CurrencyParameterSensitivity sTarget1 = sTarget.Sensitivities.get(0); assertTrue(sTarget1.MarketDataName.Equals(NAME_1)); assertTrue(sTarget1.Currency.Equals(CCY_1)); assertTrue(sTarget1.Sensitivity.size() == TARGET_DATES.Count); assertEquals(sTarget1.Sensitivity.get(WEIGHTS_START[loopdate]), WEIGHTS_HC[loopdate] * SENSITIVITY_AMOUNT, TOLERANCE_SENSI); assertEquals(sTarget1.Sensitivity.get(WEIGHTS_START[loopdate] + 1), (1.0d - WEIGHTS_HC[loopdate]) * SENSITIVITY_AMOUNT, TOLERANCE_SENSI); CurrencyParameterSensitivity sTarget2 = sTarget.Sensitivities.get(1); assertTrue(sTarget2.MarketDataName.Equals(NAME_2)); assertTrue(sTarget2.Currency.Equals(CCY_2)); assertTrue(sTarget2.Sensitivity.size() == TARGET_DATES.Count); assertEquals(sTarget2.Sensitivity.get(WEIGHTS_START[loopdate + 1]), WEIGHTS_HC[loopdate + 1] * SENSITIVITY_AMOUNT, TOLERANCE_SENSI); assertEquals(sTarget2.Sensitivity.get(WEIGHTS_START[loopdate + 1] + 1), (1.0d - WEIGHTS_HC[loopdate + 1]) * SENSITIVITY_AMOUNT, TOLERANCE_SENSI); } }
/// <summary> /// Calibrate a single curve to 4 points. Use the resulting calibrated curves as starting point of the computation /// of a Jacobian. Compare the direct Jacobian and the one reconstructed from trades. /// </summary> public virtual void direct_one_curve() { /* Create trades */ IList <ResolvedTrade> trades = new List <ResolvedTrade>(); IList <LocalDate> nodeDates = new List <LocalDate>(); for (int looptenor = 0; looptenor < TENORS_STD_1.Length; looptenor++) { ResolvedSwapTrade t0 = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA); double rate = MARKET_QUOTE.value(t0, MULTICURVE_EUR_SINGLE_CALIBRATED); ResolvedSwapTrade t = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, rate, REF_DATA).resolve(REF_DATA); nodeDates.Add(t.Product.EndDate); trades.Add(t); } /* Par rate sensitivity */ System.Func <ResolvedTrade, CurrencyParameterSensitivities> sensitivityFunction = (t) => MULTICURVE_EUR_SINGLE_CALIBRATED.parameterSensitivity(PRICER_SWAP_PRODUCT.parRateSensitivity(((ResolvedSwapTrade)t).Product, MULTICURVE_EUR_SINGLE_CALIBRATED).build()); DoubleMatrix jiComputed = CurveSensitivityUtils.jacobianFromMarketQuoteSensitivities(LIST_CURVE_NAMES_1, trades, sensitivityFunction); DoubleMatrix jiExpected = MULTICURVE_EUR_SINGLE_CALIBRATED.findData(EUR_SINGLE_NAME).get().Metadata.findInfo(CurveInfoType.JACOBIAN).get().JacobianMatrix; /* Comparison */ assertEquals(jiComputed.rowCount(), jiExpected.rowCount()); assertEquals(jiComputed.columnCount(), jiExpected.columnCount()); for (int i = 0; i < jiComputed.rowCount(); i++) { for (int j = 0; j < jiComputed.columnCount(); j++) { assertEquals(jiComputed.get(i, j), jiExpected.get(i, j), TOLERANCE_JAC); } } }
public virtual void wrong_metadata() { IList <ParameterMetadata> pmdInput = new List <ParameterMetadata>(); pmdInput.Add(TenorParameterMetadata.of(Tenor.TENOR_10M)); CurrencyParameterSensitivity s1 = CurrencyParameterSensitivity.of(NAME_1, pmdInput, CCY_1, DoubleArray.of(SENSITIVITY_AMOUNT)); CurrencyParameterSensitivities s2 = CurrencyParameterSensitivities.of(s1); assertThrowsIllegalArg(() => CurveSensitivityUtils.linearRebucketing(s2, TARGET_DATES)); }
public virtual void missing_metadata() { CurrencyParameterSensitivity s1 = CurrencyParameterSensitivity.of(NAME_1, CCY_1, DoubleArray.of(SENSITIVITY_AMOUNT)); CurrencyParameterSensitivities s2 = CurrencyParameterSensitivities.of(s1); assertThrowsIllegalArg(() => CurveSensitivityUtils.linearRebucketing(s2, TARGET_DATES)); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.LocalDate sensitivityDate = java.time.LocalDate.of(2015, 8, 18); LocalDate sensitivityDate = LocalDate.of(2015, 8, 18); assertThrowsIllegalArg(() => CurveSensitivityUtils.linearRebucketing(s2, TARGET_DATES, sensitivityDate)); }
/// <summary> /// Start from a generic zero-coupon curve. Compute the (inverse) Jacobian matrix using linear projection to a small /// number of points and the Jacobian utility. Compare the direct Jacobian obtained by calibrating a curve /// based on the trades with market quotes computed from the zero-coupon curve. /// </summary> public virtual void with_rebucketing_one_curve() { /* Create trades */ IList <ResolvedTrade> trades = new List <ResolvedTrade>(); IList <LocalDate> nodeDates = new List <LocalDate>(); double[] marketQuotes = new double[TENORS_STD_1.Length]; for (int looptenor = 0; looptenor < TENORS_STD_1.Length; looptenor++) { ResolvedSwapTrade t0 = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA); marketQuotes[looptenor] = MARKET_QUOTE.value(t0, MULTICURVE_EUR_SINGLE_INPUT); ResolvedSwapTrade t = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_1[looptenor], BuySell.BUY, 1.0, marketQuotes[looptenor], REF_DATA).resolve(REF_DATA); nodeDates.Add(t.Product.EndDate); trades.Add(t); } System.Func <ResolvedTrade, CurrencyParameterSensitivities> sensitivityFunction = (t) => CurveSensitivityUtils.linearRebucketing(MULTICURVE_EUR_SINGLE_INPUT.parameterSensitivity(PRICER_SWAP_PRODUCT.parRateSensitivity(((ResolvedSwapTrade)t).Product, MULTICURVE_EUR_SINGLE_INPUT).build()), nodeDates, VALUATION_DATE); /* Market quotes for comparison */ IDictionary <QuoteId, double> mqCmp = new Dictionary <QuoteId, double>(); for (int looptenor = 0; looptenor < TENORS_STD_1.Length; looptenor++) { mqCmp[QuoteId.of(StandardId.of(OG_TICKER, TICKERS_STD_1[looptenor]))] = marketQuotes[looptenor]; } ImmutableMarketData marketQuotesObject = ImmutableMarketData.of(VALUATION_DATE, mqCmp); RatesProvider multicurveCmp = CALIBRATOR.calibrate(GROUPS_IN_1, marketQuotesObject, REF_DATA); /* Comparison */ DoubleMatrix jiComputed = CurveSensitivityUtils.jacobianFromMarketQuoteSensitivities(LIST_CURVE_NAMES_1, trades, sensitivityFunction); DoubleMatrix jiExpected = multicurveCmp.findData(EUR_SINGLE_NAME).get().Metadata.findInfo(CurveInfoType.JACOBIAN).get().JacobianMatrix; assertEquals(jiComputed.rowCount(), jiExpected.rowCount()); assertEquals(jiComputed.columnCount(), jiExpected.columnCount()); for (int i = 0; i < jiComputed.rowCount(); i++) { for (int j = 0; j < jiComputed.columnCount(); j++) { assertEquals(jiComputed.get(i, j), jiExpected.get(i, j), TOLERANCE_JAC_APPROX); // The comparison is not perfect due to the incoherences introduced by the re-bucketing } } }
/// <summary> /// Calibrate a single curve to 4 points. Use the resulting calibrated curves as starting point of the computation /// of a Jacobian. Compare the direct Jacobian and the one reconstructed from trades. /// </summary> public virtual void direct_two_curves() { JacobianCalibrationMatrix jiObject = MULTICURVE_EUR_2_CALIBRATED.findData(EUR_DSCON_OIS).get().Metadata.findInfo(CurveInfoType.JACOBIAN).get(); ImmutableList <CurveParameterSize> order = jiObject.Order; // To obtain the order of the curves in the jacobian /* Create trades */ IList <ResolvedTrade> tradesDsc = new List <ResolvedTrade>(); for (int looptenor = 0; looptenor < TENORS_STD_2_OIS.Length; looptenor++) { ResolvedSwapTrade t0 = EUR_FIXED_1Y_EONIA_OIS.createTrade(VALUATION_DATE, TENORS_STD_2_OIS[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA); double rate = MARKET_QUOTE.value(t0, MULTICURVE_EUR_2_CALIBRATED); ResolvedSwapTrade t = EUR_FIXED_1Y_EONIA_OIS.createTrade(VALUATION_DATE, TENORS_STD_2_OIS[looptenor], BuySell.BUY, 1.0, rate, REF_DATA).resolve(REF_DATA); tradesDsc.Add(t); } IList <ResolvedTrade> tradesE3 = new List <ResolvedTrade>(); // Fixing IborFixingDepositConvention c = IborFixingDepositConvention.of(EUR_EURIBOR_6M); ResolvedIborFixingDepositTrade fix0 = c.createTrade(VALUATION_DATE, EUR_EURIBOR_6M.Tenor.Period, BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA); double rateFixing = MARKET_QUOTE.value(fix0, MULTICURVE_EUR_2_CALIBRATED); ResolvedIborFixingDepositTrade fix = c.createTrade(VALUATION_DATE, EUR_EURIBOR_6M.Tenor.Period, BuySell.BUY, 1.0, rateFixing, REF_DATA).resolve(REF_DATA); tradesE3.Add(fix); // IRS for (int looptenor = 0; looptenor < TENORS_STD_2_IRS.Length; looptenor++) { ResolvedSwapTrade t0 = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_2_IRS[looptenor], BuySell.BUY, 1.0, 0.0, REF_DATA).resolve(REF_DATA); double rate = MARKET_QUOTE.value(t0, MULTICURVE_EUR_2_CALIBRATED); ResolvedSwapTrade t = EUR_FIXED_1Y_EURIBOR_6M.createTrade(VALUATION_DATE, TENORS_STD_2_IRS[looptenor], BuySell.BUY, 1.0, rate, REF_DATA).resolve(REF_DATA); tradesE3.Add(t); } IList <ResolvedTrade> trades = new List <ResolvedTrade>(); if (order.get(0).Name.Equals(EUR_DSCON_OIS)) { ((IList <ResolvedTrade>)trades).AddRange(tradesDsc); ((IList <ResolvedTrade>)trades).AddRange(tradesE3); } else { ((IList <ResolvedTrade>)trades).AddRange(tradesE3); ((IList <ResolvedTrade>)trades).AddRange(tradesDsc); } /* Par rate sensitivity */ System.Func <ResolvedTrade, CurrencyParameterSensitivities> sensitivityFunction = (t) => MULTICURVE_EUR_2_CALIBRATED.parameterSensitivity((t is ResolvedSwapTrade) ? PRICER_SWAP_PRODUCT.parRateSensitivity(((ResolvedSwapTrade)t).Product, MULTICURVE_EUR_2_CALIBRATED).build() : PRICER_IBORFIX_PRODUCT.parRateSensitivity(((ResolvedIborFixingDepositTrade)t).Product, MULTICURVE_EUR_2_CALIBRATED)); DoubleMatrix jiComputed = CurveSensitivityUtils.jacobianFromMarketQuoteSensitivities(order, trades, sensitivityFunction); DoubleMatrix jiExpectedDsc = MULTICURVE_EUR_2_CALIBRATED.findData(EUR_DSCON_OIS).get().Metadata.getInfo(CurveInfoType.JACOBIAN).JacobianMatrix; DoubleMatrix jiExpectedE3 = MULTICURVE_EUR_2_CALIBRATED.findData(EUR_EURIBOR6M_IRS).get().Metadata.getInfo(CurveInfoType.JACOBIAN).JacobianMatrix; /* Comparison */ assertEquals(jiComputed.rowCount(), jiExpectedDsc.rowCount() + jiExpectedE3.rowCount()); assertEquals(jiComputed.columnCount(), jiExpectedDsc.columnCount()); assertEquals(jiComputed.columnCount(), jiExpectedE3.columnCount()); int shiftDsc = order.get(0).Name.Equals(EUR_DSCON_OIS) ? 0 : jiExpectedE3.rowCount(); for (int i = 0; i < jiExpectedDsc.rowCount(); i++) { for (int j = 0; j < jiExpectedDsc.columnCount(); j++) { assertEquals(jiComputed.get(i + shiftDsc, j), jiExpectedDsc.get(i, j), TOLERANCE_JAC); } } int shiftE3 = order.get(0).Name.Equals(EUR_DSCON_OIS) ? jiExpectedDsc.rowCount() : 0; for (int i = 0; i < jiExpectedE3.rowCount(); i++) { for (int j = 0; j < jiExpectedDsc.columnCount(); j++) { assertEquals(jiComputed.get(i + shiftE3, j), jiExpectedE3.get(i, j), TOLERANCE_JAC); } } }
public virtual void hard_coded_value_one_curve_one_date_dated_sd() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.LocalDate sensitivityDate = java.time.LocalDate.of(2015, 8, 18); LocalDate sensitivityDate = LocalDate.of(2015, 8, 18); System.Func <LocalDate, ParameterMetadata> parameterMetadataFunction = (d) => LabelDateParameterMetadata.of(d, "test"); System.Func <CurrencyParameterSensitivities, CurrencyParameterSensitivities> rebucketFunction = (s) => CurveSensitivityUtils.linearRebucketing(s, TARGET_DATES, sensitivityDate); test_from_functions_one_curve_one_date(parameterMetadataFunction, rebucketFunction); }
public virtual void hard_coded_value_one_curve_one_date_dated() { System.Func <LocalDate, ParameterMetadata> parameterMetadataFunction = (d) => LabelDateParameterMetadata.of(d, "test"); System.Func <CurrencyParameterSensitivities, CurrencyParameterSensitivities> rebucketFunction = (s) => CurveSensitivityUtils.linearRebucketing(s, TARGET_DATES); test_from_functions_one_curve_one_date(parameterMetadataFunction, rebucketFunction); }
public virtual void hard_coded_value_one_curve_all_dates_tenor() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.LocalDate sensitivityDate = java.time.LocalDate.of(2015, 8, 18); LocalDate sensitivityDate = LocalDate.of(2015, 8, 18); System.Func <LocalDate, ParameterMetadata> parameterMetadataFunction = (d) => TenorParameterMetadata.of(Tenor.of(Period.ofDays((int)(d.toEpochDay() - sensitivityDate.toEpochDay())))); System.Func <CurrencyParameterSensitivities, CurrencyParameterSensitivities> rebucketFunction = (s) => CurveSensitivityUtils.linearRebucketing(s, TARGET_DATES, sensitivityDate); test_from_functions_one_curve_all_dates(parameterMetadataFunction, rebucketFunction); }