DiscountCurveRegressor.java

  1. package org.drip.regression.curve;

  3. /*
  4.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  5.  */

  7. /*!
  8.  * Copyright (C) 2020 Lakshmi Krishnamurthy
  9.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  10.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  11.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  12.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  13.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  14.  * Copyright (C) 2014 Lakshmi Krishnamurthy
  15.  * Copyright (C) 2013 Lakshmi Krishnamurthy
  16.  * Copyright (C) 2012 Lakshmi Krishnamurthy
  17.  * 
  18.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  19.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  20.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  21.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  22.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  23.  *      and computational support.
  24.  *  
  25.  *      https://lakshmidrip.github.io/DROP/
  26.  *  
  27.  *  DROP is composed of three modules:
  28.  *  
  29.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  30.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  31.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  32.  * 
  33.  *  DROP Product Core implements libraries for the following:
  34.  *  - Fixed Income Analytics
  35.  *  - Loan Analytics
  36.  *  - Transaction Cost Analytics
  37.  * 
  38.  *  DROP Portfolio Core implements libraries for the following:
  39.  *  - Asset Allocation Analytics
  40.  *  - Asset Liability Management Analytics
  41.  *  - Capital Estimation Analytics
  42.  *  - Exposure Analytics
  43.  *  - Margin Analytics
  44.  *  - XVA Analytics
  45.  * 
  46.  *  DROP Computational Core implements libraries for the following:
  47.  *  - Algorithm Support
  48.  *  - Computation Support
  49.  *  - Function Analysis
  50.  *  - Model Validation
  51.  *  - Numerical Analysis
  52.  *  - Numerical Optimizer
  53.  *  - Spline Builder
  54.  *  - Statistical Learning
  55.  * 
  56.  *  Documentation for DROP is Spread Over:
  57.  * 
  58.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  59.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  60.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  61.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  62.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  63.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  64.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  65.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  66.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  67.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  68.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  69.  * 
  70.  *  Licensed under the Apache License, Version 2.0 (the "License");
  71.  *      you may not use this file except in compliance with the License.
  72.  *   
  73.  *  You may obtain a copy of the License at
  74.  *      http://www.apache.org/licenses/LICENSE-2.0
  75.  *  
  76.  *  Unless required by applicable law or agreed to in writing, software
  77.  *      distributed under the License is distributed on an "AS IS" BASIS,
  78.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  79.  *  
  80.  *  See the License for the specific language governing permissions and
  81.  *      limitations under the License.
  82.  */

  84. /**
  85.  * <i>DiscountCurveRegressor</i> implements the regression set analysis for the Discount Curve.
  86.  * DiscountCurveRegressor regresses 11 scenarios:
  87.  * 
  88.  * <br><br>
  89.  *  <ul>
  90.  *      <li>
  91.  *          #1: Create the discount curve from a set 30 instruments (cash/future/swap).
  92.  *      </li>
  93.  *      <li>
  94.  *          #2: Create the discount curve from a flat discount rate.
  95.  *      </li>
  96.  *      <li>
  97.  *          #3: Create the discount curve from a set of discount factors.
  98.  *      </li>
  99.  *      <li>
  100.  *          #4: Create the discount curve from the implied discount rates.
  101.  *      </li>
  102.  *      <li>
  103.  *          #5: Extract the discount curve instruments and quotes.
  104.  *      </li>
  105.  *      <li>
  106.  *          #6: Create a parallel shifted discount curve.
  107.  *      </li>
  108.  *      <li>
  109.  *          #7: Create a rate shifted discount curve.
  110.  *      </li>
  111.  *      <li>
  112.  *          #8: Create a basis rate shifted discount curve.
  113.  *      </li>
  114.  *      <li>
  115.  *          #9: Create a node tweaked discount curve.
  116.  *      </li>
  117.  *      <li>
  118.  *          #10: Compute the effective discount factor between 2 dates.
  119.  *      </li>
  120.  *      <li>
  121.  *          #11: Compute the effective implied rate between 2 dates.
  122.  *      </li>
  123.  *  </ul>
  124.  * 
  125.  * <br><br>
  126.  *  <ul>
  127.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  128.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationSupportLibrary.md">Computation Support</a></li>
  129.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/regression/README.md">Regression Engine Core and the Unit Regressors</a></li>
  130.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/regression/curve/README.md">Curve Construction/Reconciliation Regression Engine</a></li>
  131.  *  </ul>
  132.  * <br><br>
  133.  *
  134.  * @author Lakshmi Krishnamurthy
  135.  */

  137. public class DiscountCurveRegressor implements org.drip.regression.core.RegressorSet {
  138.     private java.lang.String _strCurrency = "";
  139.     private org.drip.state.discount.MergedDiscountForwardCurve _dc = null;
  140.     private org.drip.analytics.date.JulianDate _dtStart = null;
  141.     private org.drip.state.discount.ExplicitBootDiscountCurve _dcFromFlatRate = null;
  142.     private java.lang.String _strRegressionScenario = "org.drip.analytics.curve.DiscountCurve";

  144.     private java.util.List<org.drip.regression.core.UnitRegressor> _setRegressors = new
  145.         java.util.ArrayList<org.drip.regression.core.UnitRegressor>();

  147.     /**
  148.      * Do Nothing DiscountCurveRegressor constructor
  149.      */

  151.     public DiscountCurveRegressor()
  152.     {
  153.     }

  155.     /*
  156.      * Discount Curve Regressor set setup
  157.      */

  159.     @Override public boolean setupRegressors()
  160.     {
  161.         /*
  162.          * Testing creation of the Discount Curve from rates instruments - implements the pre-regression, the
  163.          *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  164.          */

  166.         try {
  167.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor
  168.                 ("CreateFromRatesInstruments", _strRegressionScenario)
  169.             {
  170.                 private static final int NUM_DC_INSTR = 30;

  172.                 private double _adblCompCalibValue[] = new double[NUM_DC_INSTR];
  173.                 private java.lang.String _astrCalibMeasure[] = new java.lang.String[NUM_DC_INSTR];
  174.                 private org.drip.product.definition.CalibratableComponent _aCompCalib[] = new
  175.                     org.drip.product.definition.CalibratableComponent[NUM_DC_INSTR];

  177.                 private org.drip.param.market.LatentStateFixingsContainer _lsfc = new
  178.                     org.drip.param.market.LatentStateFixingsContainer();

  180.                 @Override public boolean preRegression()
  181.                 {
  182.                     _strCurrency = "CHF";
  183.                     int aiDate[] = new int[NUM_DC_INSTR];
  184.                     double adblRate[] = new double[NUM_DC_INSTR];

  186.                     if (null == (_dtStart = org.drip.analytics.date.DateUtil.CreateFromYMD (2010,
  187.                         org.drip.analytics.date.DateUtil.MAY, 12)))
  188.                         return false;

  190.                     aiDate[0] = _dtStart.addDays (3).julian(); // ON

  192.                     aiDate[1] = _dtStart.addDays (4).julian(); // 1D (TN)

  194.                     aiDate[2] = _dtStart.addDays (9).julian(); // 1W

  196.                     aiDate[3] = _dtStart.addDays (16).julian(); // 2W

  198.                     aiDate[4] = _dtStart.addDays (32).julian(); // 1M

  200.                     aiDate[5] = _dtStart.addDays (62).julian(); // 2M

  202.                     aiDate[6] = _dtStart.addDays (92).julian(); // 3M

  204.                     _adblCompCalibValue[0] = .0013;
  205.                     _adblCompCalibValue[1] = .0017;
  206.                     _adblCompCalibValue[2] = .0017;
  207.                     _adblCompCalibValue[3] = .0018;
  208.                     _adblCompCalibValue[4] = .0020;
  209.                     _adblCompCalibValue[5] = .0023;
  210.                     _adblCompCalibValue[6] = .0026;

  212.                     for (int i = 0; i < 7; ++i) {
  213.                         _astrCalibMeasure[i] = "Rate";
  214.                         adblRate[i] = java.lang.Double.NaN;

  216.                         try {
  217.                             _aCompCalib[i] = org.drip.product.creator.SingleStreamComponentBuilder.Deposit
  218.                                 (_dtStart.addDays (2), new org.drip.analytics.date.JulianDate (aiDate[i]),
  219.                                     org.drip.state.identifier.ForwardLabel.Create (_strCurrency, "3M"));
  220.                         } catch (java.lang.Exception e) {
  221.                             e.printStackTrace();

  223.                             return false;
  224.                         }
  225.                     }

  227.                     _adblCompCalibValue[7] = .0027;
  228.                     _adblCompCalibValue[8] = .0032;
  229.                     _adblCompCalibValue[9] = .0041;
  230.                     _adblCompCalibValue[10] = .0054;
  231.                     _adblCompCalibValue[11] = .0077;
  232.                     _adblCompCalibValue[12] = .0104;
  233.                     _adblCompCalibValue[13] = .0134;
  234.                     _adblCompCalibValue[14] = .0160;
  235.                     org.drip.analytics.date.JulianDate dtEDFStart = _dtStart;

  237.                     org.drip.product.definition.CalibratableComponent[] aEDF =
  238.                         org.drip.product.creator.SingleStreamComponentBuilder.ForwardRateFuturesPack
  239.                             (_dtStart, 8, _strCurrency);

  241.                     for (int i = 0; i < 8; ++i) {
  242.                         _aCompCalib[i + 7] = aEDF[i];
  243.                         _astrCalibMeasure[i + 7] = "Rate";
  244.                         adblRate[i + 7] = java.lang.Double.NaN;

  246.                         aiDate[i + 7] = dtEDFStart.addDays ((i + 1) * 91).julian();
  247.                     }

  249.                     aiDate[15] = _dtStart.addDays ((int)(365.25 * 4 + 2)).julian(); // 4Y

  251.                     aiDate[16] = _dtStart.addDays ((int)(365.25 * 5 + 2)).julian(); // 5Y

  253.                     aiDate[17] = _dtStart.addDays ((int)(365.25 * 6 + 2)).julian(); // 6Y

  255.                     aiDate[18] = _dtStart.addDays ((int)(365.25 * 7 + 2)).julian(); // 7Y

  257.                     aiDate[19] = _dtStart.addDays ((int)(365.25 * 8 + 2)).julian(); // 8Y

  259.                     aiDate[20] = _dtStart.addDays ((int)(365.25 * 9 + 2)).julian(); // 9Y

  261.                     aiDate[21] = _dtStart.addDays ((int)(365.25 * 10 + 2)).julian(); // 10Y

  263.                     aiDate[22] = _dtStart.addDays ((int)(365.25 * 11 + 2)).julian(); // 11Y

  265.                     aiDate[23] = _dtStart.addDays ((int)(365.25 * 12 + 2)).julian(); // 12Y

  267.                     aiDate[24] = _dtStart.addDays ((int)(365.25 * 15 + 2)).julian(); // 15Y

  269.                     aiDate[25] = _dtStart.addDays ((int)(365.25 * 20 + 2)).julian(); // 20Y

  271.                     aiDate[26] = _dtStart.addDays ((int)(365.25 * 25 + 2)).julian(); // 25Y

  273.                     aiDate[27] = _dtStart.addDays ((int)(365.25 * 30 + 2)).julian(); // 30Y

  275.                     aiDate[28] = _dtStart.addDays ((int)(365.25 * 40 + 2)).julian(); // 40Y

  277.                     aiDate[29] = _dtStart.addDays ((int)(365.25 * 50 + 2)).julian(); // 50Y

  279.                     _adblCompCalibValue[15] = .0166;
  280.                     _adblCompCalibValue[16] = .0206;
  281.                     _adblCompCalibValue[17] = .0241;
  282.                     _adblCompCalibValue[18] = .0269;
  283.                     _adblCompCalibValue[19] = .0292;
  284.                     _adblCompCalibValue[20] = .0311;
  285.                     _adblCompCalibValue[21] = .0326;
  286.                     _adblCompCalibValue[22] = .0340;
  287.                     _adblCompCalibValue[23] = .0351;
  288.                     _adblCompCalibValue[24] = .0375;
  289.                     _adblCompCalibValue[25] = .0393;
  290.                     _adblCompCalibValue[26] = .0402;
  291.                     _adblCompCalibValue[27] = .0407;
  292.                     _adblCompCalibValue[28] = .0409;
  293.                     _adblCompCalibValue[29] = .0409;
  294.                     org.drip.param.period.CompositePeriodSetting cpsFixed = null;
  295.                     org.drip.param.period.CompositePeriodSetting cpsFloating = null;
  296.                     org.drip.param.period.UnitCouponAccrualSetting ucasFixed = null;
  297.                     org.drip.param.period.ComposableFixedUnitSetting cfusFixed = null;
  298.                     org.drip.param.period.ComposableFloatingUnitSetting cfusFloating = null;

  300.                     try {
  301.                         ucasFixed = new org.drip.param.period.UnitCouponAccrualSetting (2, "Act/360", false,
  302.                             "Act/360", false, _strCurrency, true,
  303.                                 org.drip.analytics.support.CompositePeriodBuilder.ACCRUAL_COMPOUNDING_RULE_GEOMETRIC);

  305.                         cfusFloating = new org.drip.param.period.ComposableFloatingUnitSetting ("3M",
  306.                             org.drip.analytics.support.CompositePeriodBuilder.EDGE_DATE_SEQUENCE_SINGLE,
  307.                                 null, org.drip.state.identifier.ForwardLabel.Standard (_strCurrency + "-3M"),
  308.                                     org.drip.analytics.support.CompositePeriodBuilder.REFERENCE_PERIOD_IN_ADVANCE,
  309.                             0.);

  311.                         cfusFixed = new org.drip.param.period.ComposableFixedUnitSetting ("6M",
  312.                             org.drip.analytics.support.CompositePeriodBuilder.EDGE_DATE_SEQUENCE_REGULAR,
  313.                                 null, 0., 0., _strCurrency);

  315.                         cpsFloating = new org.drip.param.period.CompositePeriodSetting (4, "3M",
  316.                             _strCurrency, null, -1., null, null, null, null);

  318.                         cpsFixed = new org.drip.param.period.CompositePeriodSetting (2, "6M", _strCurrency,
  319.                             null, 1., null, null, null, null);
  320.                     } catch (java.lang.Exception e) {
  321.                         e.printStackTrace();

  323.                         return false;
  324.                     }

  326.                     for (int i = 0; i < 15; ++i) {
  327.                         _astrCalibMeasure[i + 15] = "Rate";
  328.                         adblRate[i + 15] = java.lang.Double.NaN;

  330.                         try {
  331.                             org.drip.analytics.date.JulianDate dtMaturity = new
  332.                                 org.drip.analytics.date.JulianDate (aiDate[i + 15]);

  334.                             java.util.List<java.lang.Integer> lsFixedStreamEdgeDate =
  335.                                 org.drip.analytics.support.CompositePeriodBuilder.BackwardEdgeDates
  336.                                     (_dtStart, dtMaturity, "6M", null,
  337.                                         org.drip.analytics.support.CompositePeriodBuilder.SHORT_STUB);

  339.                             java.util.List<java.lang.Integer> lsFloatingStreamEdgeDate =
  340.                                 org.drip.analytics.support.CompositePeriodBuilder.BackwardEdgeDates
  341.                                     (_dtStart, dtMaturity, "3M", null,
  342.                                         org.drip.analytics.support.CompositePeriodBuilder.SHORT_STUB);

  344.                             org.drip.product.rates.Stream floatingStream = new org.drip.product.rates.Stream
  345.                                 (org.drip.analytics.support.CompositePeriodBuilder.FloatingCompositeUnit
  346.                                     (lsFloatingStreamEdgeDate, cpsFloating, cfusFloating));

  348.                             org.drip.product.rates.Stream fixedStream = new org.drip.product.rates.Stream
  349.                                 (org.drip.analytics.support.CompositePeriodBuilder.FixedCompositeUnit
  350.                                     (lsFixedStreamEdgeDate, cpsFixed, ucasFixed, cfusFixed));

  352.                             _aCompCalib[i + 15] = new org.drip.product.rates.FixFloatComponent (fixedStream,
  353.                                 floatingStream, null);
  354.                         } catch (java.lang.Exception e) {
  355.                             e.printStackTrace();

  357.                             return false;
  358.                         }
  359.                     }

  361.                     _lsfc.add (_dtStart.addDays (2), org.drip.state.identifier.ForwardLabel.Standard
  362.                         (_strCurrency + "-6M"), 0.0042);

  364.                     return true;
  365.                 }

  367.                 @Override public boolean execRegression()
  368.                 {
  369.                     return null != (_dc = org.drip.state.creator.ScenarioDiscountCurveBuilder.NonlinearBuild
  370.                         (_dtStart, _strCurrency, _aCompCalib, _adblCompCalibValue, _astrCalibMeasure,
  371.                             _lsfc));
  372.                 }
  373.             });

  375.             /*
  376.              * Testing creation of the Discount Curve from a flat rate - implements the pre-regression, the
  377.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  378.              */

  380.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("CreateFromFlatRate",
  381.                 _strRegressionScenario)
  382.             {
  383.                 @Override public boolean execRegression()
  384.                 {
  385.                     return null != (_dcFromFlatRate =
  386.                         org.drip.state.creator.ScenarioDiscountCurveBuilder.ExponentiallyCompoundedFlatRate
  387.                             (_dtStart, _strCurrency, 0.04));
  388.                 }

  390.                 @Override public boolean postRegression (
  391.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  392.                 {
  393.                     final int NUM_DC_INSTRUMENTS = 5;
  394.                     int aiDate[] = new int[NUM_DC_INSTRUMENTS];
  395.                     double adblDiscountFactorFlatRate[] = new double[NUM_DC_INSTRUMENTS];

  397.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  398.                         try {
  399.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblDiscountFactorFlatRate[i] =
  400.                                 _dcFromFlatRate.df (aiDate[i] = _dtStart.addYears (i + 1).julian())))
  401.                                 return false;

  403.                             rnvd.set ("DiscountFactor[" + new org.drip.analytics.date.JulianDate
  404.                                 (aiDate[i]) + "]", "" + adblDiscountFactorFlatRate[i]);
  405.                         } catch (java.lang.Exception e) {
  406.                             e.printStackTrace();

  408.                             return false;
  409.                         }
  410.                     }

  412.                     return true;
  413.                 }
  414.             });

  416.             /*
  417.              * Testing creation of the Discount Curve from discount factors - implements the pre-regression,
  418.              *  the post-regression, and the actual regression functionality of the UnitRegressorExecutor
  419.              *      class.
  420.              */

  422.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("BuildFromDF",
  423.                 _strRegressionScenario)
  424.             {
  425.                 private static final int NUM_DC_INSTRUMENTS = 5;

  427.                 private int _aiDate[] = new int[NUM_DC_INSTRUMENTS];
  428.                 private org.drip.state.discount.MergedDiscountForwardCurve _dcFromDF = null;
  429.                 private double _adblDiscountFactorFlatRate[] = new double[NUM_DC_INSTRUMENTS];

  431.                 @Override public boolean preRegression()
  432.                 {
  433.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  434.                         try {
  435.                             if (!org.drip.numerical.common.NumberUtil.IsValid (_adblDiscountFactorFlatRate[i] =
  436.                                 _dc.df (_aiDate[i] = _dtStart.addYears (i + 1).julian())))
  437.                                 return false;
  438.                         } catch (java.lang.Exception e) {
  439.                             e.printStackTrace();

  441.                             return false;
  442.                         }
  443.                     }

  445.                     return true;
  446.                 }

  448.                 @Override public boolean execRegression()
  449.                 {
  450.                     return null != (_dcFromDF =
  451.                         org.drip.state.creator.ScenarioDiscountCurveBuilder.BuildFromDF (_dtStart,
  452.                             _strCurrency, _aiDate, _adblDiscountFactorFlatRate));
  453.                 }

  455.                 @Override public boolean postRegression (
  456.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  457.                 {
  458.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  459.                         try {
  460.                             double dblDiscountFactorDFCurve = _dcFromDF.df (_aiDate[i]);

  462.                             rnvd.set ("DiscountFactorFlatRate[" + new org.drip.analytics.date.JulianDate
  463.                                 (_aiDate[i]) + "]", org.drip.numerical.common.FormatUtil.FormatDouble
  464.                                     (_adblDiscountFactorFlatRate[i], 1, 3, 1));

  466.                             rnvd.set ("DiscountFactorDFCurve[" + new org.drip.analytics.date.JulianDate
  467.                                 (_aiDate[i]) + "]", org.drip.numerical.common.FormatUtil.FormatDouble
  468.                                     (dblDiscountFactorDFCurve, 1, 3, 1));

  470.                             if (!org.drip.numerical.common.NumberUtil.WithinTolerance (dblDiscountFactorDFCurve,
  471.                                 _adblDiscountFactorFlatRate[i]))
  472.                                 return false;
  473.                         } catch (java.lang.Exception e) {
  474.                             e.printStackTrace();

  476.                             return false;
  477.                         }
  478.                     }

  480.                     return true;
  481.                 }
  482.             });

  484.             /*
  485.              * Testing creation of the Discount Curve from rates nodes - implements the pre-regression, the
  486.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  487.              */

  489.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("CreateDC",
  490.                 _strRegressionScenario)
  491.             {
  492.                 private static final int NUM_DC_INSTRUMENTS = 5;

  494.                 private int _aiDate[] = new int[NUM_DC_INSTRUMENTS];
  495.                 private double _adblRate[] = new double[NUM_DC_INSTRUMENTS];
  496.                 private org.drip.state.discount.MergedDiscountForwardCurve _dcFromRates = null;

  498.                 @Override public boolean preRegression()
  499.                 {
  500.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  501.                         try {
  502.                             if (!org.drip.numerical.common.NumberUtil.IsValid (_adblRate[i] = _dc.zero
  503.                                 (_aiDate[i] = _dtStart.addYears (i + 1).julian())))
  504.                                 return false;
  505.                         } catch (java.lang.Exception e) {
  506.                             e.printStackTrace();

  508.                             return false;
  509.                         }
  510.                     }

  512.                     return true;
  513.                 }

  515.                 @Override public boolean execRegression()
  516.                 {
  517.                     return null != (_dcFromRates =
  518.                         org.drip.state.creator.ScenarioDiscountCurveBuilder.PiecewiseForward (_dtStart,
  519.                             _strCurrency, _aiDate, _adblRate));
  520.                 }

  522.                 @Override public boolean postRegression (
  523.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  524.                 {
  525.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  526.                         try {
  527.                             int iStartDate = _dtStart.julian();

  529.                             if (0 != i) iStartDate = _aiDate[i - 1];

  531.                             double dblRate = _dcFromRates.forward (iStartDate, _aiDate[i]);

  533.                             rnvd.set ("DiscountFactorOriginalDC[" + new org.drip.analytics.date.JulianDate
  534.                                 (_aiDate[i]) + "]", org.drip.numerical.common.FormatUtil.FormatDouble
  535.                                     (_adblRate[i], 1, 3, 1));

  537.                             rnvd.set ("DiscountFactoRateImplied[" + new org.drip.analytics.date.JulianDate
  538.                                 (_aiDate[i]) + "]", org.drip.numerical.common.FormatUtil.FormatDouble (dblRate,
  539.                                     1, 3, 1));

  541.                             if (!org.drip.numerical.common.NumberUtil.WithinTolerance (dblRate, _adblRate[i]))
  542.                                 return false;
  543.                         } catch (java.lang.Exception e) {
  544.                             e.printStackTrace();

  546.                             return false;
  547.                         }
  548.                     }

  550.                     return true;
  551.                 }
  552.             });

  554.             /*
  555.              * Testing the extraction of the components and quotes - implements the pre-regression, the
  556.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  557.              */

  559.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("CompAndQuotes",
  560.                 _strRegressionScenario)
  561.             {
  562.                 private org.drip.product.definition.CalibratableComponent[] _aCalibComp = null;

  564.                 @Override public boolean execRegression()
  565.                 {
  566.                     return null != (_aCalibComp = _dc.calibComp()) && 0 != _aCalibComp.length;
  567.                 }

  569.                 @Override public boolean postRegression (
  570.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  571.                 {
  572.                     for (int i = 0; i < _aCalibComp.length; ++i) {
  573.                         java.lang.String strCalibCompCode = _aCalibComp[i].primaryCode();

  575.                         try {
  576.                             double dblQuote = _dc.manifestMeasure (strCalibCompCode).get ("Rate");

  578.                             org.drip.analytics.date.JulianDate dt = _aCalibComp[i].maturityDate();

  580.                             rnvd.set ("CompQuote" + "_" + strCalibCompCode + "{" + dt + "}",
  581.                                 org.drip.numerical.common.FormatUtil.FormatDouble (dblQuote, 1, 4, 1));
  582.                         } catch (java.lang.Exception e) {
  583.                             e.printStackTrace();

  585.                             return false;
  586.                         }
  587.                     }

  589.                     return true;
  590.                 }
  591.             });

  593.             /*
  594.              * Testing creation of the Parallel-shifted Discount Curve - implements the pre-regression, the
  595.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  596.              */

  598.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("ParallelShiftedCurve",
  599.                 _strRegressionScenario)
  600.             {
  601.                 private org.drip.state.discount.MergedDiscountForwardCurve _dcShifted = null;

  603.                 @Override public boolean execRegression()
  604.                 {
  605.                     return null != (_dcShifted = (org.drip.state.discount.MergedDiscountForwardCurve)
  606.                         _dc.parallelShiftManifestMeasure ("Rate", 0.0004));
  607.                 }

  609.                 @Override public boolean postRegression (
  610.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  611.                 {
  612.                     org.drip.product.definition.CalibratableComponent[] aCalibComp =
  613.                         _dc.calibComp();

  615.                     for (int i = 0; i < aCalibComp.length; ++i) {
  616.                         java.lang.String strCalibCompCode = aCalibComp[i].primaryCode();

  618.                         try {
  619.                             double dblQuote = _dc.manifestMeasure (strCalibCompCode).get ("Rate");

  621.                             double dblQuoteShifted = _dcShifted.manifestMeasure (strCalibCompCode).get
  622.                                 ("Rate");

  624.                             rnvd.set ("BaseCurve" + "_" + strCalibCompCode,
  625.                                 org.drip.numerical.common.FormatUtil.FormatDouble (dblQuote, 1, 4, 1));

  627.                             rnvd.set ("ParallelShiftedCurve" + "_" + strCalibCompCode,
  628.                                 org.drip.numerical.common.FormatUtil.FormatDouble (dblQuoteShifted, 1, 4, 1));
  629.                         } catch (java.lang.Exception e) {
  630.                             e.printStackTrace();

  632.                             return false;
  633.                         }
  634.                     }

  636.                     return true;
  637.                 }
  638.             });

  640.             /*
  641.              * Testing creation of the Rate-shifted Discount Curve - implements the pre-regression, the
  642.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  643.              */

  645.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("RateShiftedCurve",
  646.                 _strRegressionScenario)
  647.             {
  648.                 private org.drip.state.discount.MergedDiscountForwardCurve _dcShifted = null;

  650.                 @Override public boolean execRegression()
  651.                 {
  652.                     return null != (_dcShifted = (org.drip.state.discount.MergedDiscountForwardCurve)
  653.                         _dcFromFlatRate.parallelShiftManifestMeasure ("Rate", 0.0004));
  654.                 }

  656.                 @Override public boolean postRegression (
  657.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  658.                 {
  659.                     final int NUM_DC_INSTRUMENTS = 5;
  660.                     int aiDate[] = new int[NUM_DC_INSTRUMENTS];
  661.                     double adblRate[] = new double[NUM_DC_INSTRUMENTS];
  662.                     double adblRateShifted[] = new double[NUM_DC_INSTRUMENTS];

  664.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  665.                         try {
  666.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblRate[i] = _dcFromFlatRate.zero
  667.                                 (aiDate[i] = _dtStart.addYears (i + 1).julian())))
  668.                                 return false;

  670.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblRateShifted[i] =
  671.                                 _dcShifted.zero (aiDate[i] = _dtStart.addYears (i + 1).julian())))
  672.                                 return false;

  674.                             org.drip.analytics.date.JulianDate dt = new org.drip.analytics.date.JulianDate
  675.                                 (aiDate[i]);

  677.                             rnvd.set ("RateBase[" + dt + "]", org.drip.numerical.common.FormatUtil.FormatDouble
  678.                                 (adblRate[i], 1, 4, 1));

  680.                             rnvd.set ("RateShifted[" + dt + "]",
  681.                                 org.drip.numerical.common.FormatUtil.FormatDouble (adblRateShifted[i], 1, 4, 1));

  683.                             if (!org.drip.numerical.common.NumberUtil.WithinTolerance (adblRate[i] + 0.0004,
  684.                                 adblRateShifted[i]))
  685.                                 return false;
  686.                         } catch (java.lang.Exception e) {
  687.                             e.printStackTrace();

  689.                             return false;
  690.                         }
  691.                     }

  693.                     return true;
  694.                 }
  695.             });

  697.             /*
  698.              * Testing creation of the basis rate-shifted Discount Curve - implements the pre-regression, the
  699.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  700.              */

  702.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("BasisRateShiftedCurve",
  703.                 _strRegressionScenario)
  704.             {
  705.                 private static final int NUM_DC_INSTRUMENTS = 5;

  707.                 private int _aiDate[] = new int[NUM_DC_INSTRUMENTS];
  708.                 private double _adblBasis[] = new double[NUM_DC_INSTRUMENTS];
  709.                 private org.drip.state.discount.MergedDiscountForwardCurve _dcBasisShifted = null;

  711.                 @Override public boolean preRegression()
  712.                 {
  713.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  714.                         _adblBasis[i] = (i + 1) * 0.0001;

  716.                         _aiDate[i] = _dtStart.addYears (i + 1).julian();
  717.                     }

  719.                     return true;
  720.                 }

  722.                 @Override public boolean execRegression()
  723.                 {
  724.                     return null != (_dcBasisShifted = _dcFromFlatRate.createBasisRateShiftedCurve (_aiDate,
  725.                         _adblBasis));
  726.                 }

  728.                 @Override public boolean postRegression (
  729.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  730.                 {
  731.                     double adblRate[] = new double[NUM_DC_INSTRUMENTS];
  732.                     double adblRateShifted[] = new double[NUM_DC_INSTRUMENTS];

  734.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  735.                         try {
  736.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblRate[i] = _dcFromFlatRate.zero
  737.                                 (_aiDate[i])))
  738.                                 return false;

  740.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblRateShifted[i] =
  741.                                 _dcBasisShifted.zero (_aiDate[i])))
  742.                                 return false;

  744.                             org.drip.analytics.date.JulianDate dt = new org.drip.analytics.date.JulianDate
  745.                                 (_aiDate[i]);

  747.                             rnvd.set ("RateBasisEmpty[" + dt + "]",
  748.                                 org.drip.numerical.common.FormatUtil.FormatDouble (adblRate[i], 1, 4, 1));

  750.                             rnvd.set ("RateBasisShifted[" + dt + "]",
  751.                                 org.drip.numerical.common.FormatUtil.FormatDouble (adblRateShifted[i], 1, 4, 1));
  752.                         } catch (java.lang.Exception e) {
  753.                             e.printStackTrace();

  755.                             return false;
  756.                         }
  757.                     }

  759.                     return true;
  760.                 }
  761.             });

  763.             /*
  764.              * Testing creation of the Tweaked Discount Curve - implements the pre-regression, the
  765.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  766.              */

  768.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("CreateTweakedCurve",
  769.                 _strRegressionScenario)
  770.             {
  771.                 private static final int NUM_DC_INSTRUMENTS = 5;

  773.                 private int _aiDate[] = new int[NUM_DC_INSTRUMENTS];
  774.                 private org.drip.state.discount.MergedDiscountForwardCurve _dcNTP = null;
  775.                 private org.drip.param.definition.ManifestMeasureTweak _ntp = null;

  777.                 @Override public boolean preRegression()
  778.                 {
  779.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i)
  780.                         _aiDate[i] = _dtStart.addYears (i + 1).julian();

  782.                     try {
  783.                         _ntp = new org.drip.param.definition.ManifestMeasureTweak (0, false, 0.0005);
  784.                     } catch (java.lang.Exception e) {
  785.                         e.printStackTrace();

  787.                         return false;
  788.                     }

  790.                     return true;
  791.                 }

  793.                 @Override public boolean execRegression()
  794.                 {
  795.                     return null != (_dcNTP = (org.drip.state.discount.MergedDiscountForwardCurve)
  796.                         _dcFromFlatRate.customTweakManifestMeasure ("Rate", _ntp));
  797.                 }

  799.                 @Override public boolean postRegression (
  800.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  801.                 {
  802.                     double adblRate[] = new double[NUM_DC_INSTRUMENTS];
  803.                     double adblRateNTP[] = new double[NUM_DC_INSTRUMENTS];

  805.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  806.                         try {
  807.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblRate[i] = _dcFromFlatRate.zero
  808.                                 (_aiDate[i])))
  809.                                 return false;

  811.                             if (!org.drip.numerical.common.NumberUtil.IsValid (adblRateNTP[i] = _dcNTP.zero
  812.                                 (_aiDate[i])))
  813.                                 return false;

  815.                             org.drip.analytics.date.JulianDate dt = new org.drip.analytics.date.JulianDate
  816.                                 (_aiDate[i]);

  818.                             rnvd.set ("RateUnTweaked[" + dt + "]",
  819.                                 org.drip.numerical.common.FormatUtil.FormatDouble (adblRate[i], 1, 4, 1));

  821.                             rnvd.set ("RateTweaked[" + dt + "]",
  822.                                 org.drip.numerical.common.FormatUtil.FormatDouble (adblRateNTP[i], 1, 4, 1));

  824.                             if (!org.drip.numerical.common.NumberUtil.WithinTolerance (adblRate[i] + 0.0005,
  825.                                 adblRateNTP[i]))
  826.                                 return false;
  827.                         } catch (java.lang.Exception e) {
  828.                             e.printStackTrace();

  830.                             return false;
  831.                         }
  832.                     }

  834.                     return true;
  835.                 }
  836.             });

  838.             /*
  839.              * Testing calc of Effective DF for the Discount Curve - implements the pre-regression, the
  840.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  841.              */

  843.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("EffectiveDF",
  844.                 _strRegressionScenario)
  845.             {
  846.                 private static final int NUM_DC_INSTRUMENTS = 5;

  848.                 private int _aiDate[] = new int[NUM_DC_INSTRUMENTS];
  849.                 private double _adblDiscountFactor[] = new double[NUM_DC_INSTRUMENTS];

  851.                 @Override public boolean preRegression()
  852.                 {
  853.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i)
  854.                         _aiDate[i] = _dtStart.addYears (i + 1).julian();

  856.                     return true;
  857.                 }

  859.                 @Override public boolean execRegression()
  860.                 {
  861.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  862.                         try {
  863.                             if (!org.drip.numerical.common.NumberUtil.IsValid (_adblDiscountFactor[i] =
  864.                                 _dc.effectiveDF ((i + 1) + "Y", (i + 2) + "Y")))
  865.                                 return false;
  866.                         } catch (java.lang.Exception e) {
  867.                             e.printStackTrace();

  869.                             return false;
  870.                         }
  871.                     }

  873.                     return true;
  874.                 }

  876.                 @Override public boolean postRegression (
  877.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  878.                 {
  879.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  880.                         try {
  881.                             rnvd.set ("Effective[" + new org.drip.analytics.date.JulianDate (_aiDate[i]) +
  882.                                 "]", org.drip.numerical.common.FormatUtil.FormatDouble (_adblDiscountFactor[i],
  883.                                     1, 4, 1));
  884.                         } catch (java.lang.Exception e) {
  885.                             e.printStackTrace();

  887.                             return false;
  888.                         }
  889.                     }

  891.                     return true;
  892.                 }
  893.             });

  895.             /*
  896.              * Testing calc of Effective Rate for the Discount Curve - implements the pre-regression, the
  897.              *  post-regression, and the actual regression functionality of the UnitRegressorExecutor class.
  898.              */

  900.             _setRegressors.add (new org.drip.regression.core.UnitRegressionExecutor ("CalcImpliedRate",
  901.                 _strRegressionScenario)
  902.             {
  903.                 private static final int NUM_DC_INSTRUMENTS = 5;

  905.                 private int _aiDate[] = new int[NUM_DC_INSTRUMENTS];
  906.                 private double _adblImpliedRate[] = new double[NUM_DC_INSTRUMENTS];

  908.                 @Override public boolean preRegression()
  909.                 {
  910.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i)
  911.                         _aiDate[i] = _dtStart.addYears (i + 1).julian();

  913.                     return true;
  914.                 }

  916.                 @Override public boolean execRegression()
  917.                 {
  918.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  919.                         try {
  920.                             if (!org.drip.numerical.common.NumberUtil.IsValid (_adblImpliedRate[i] = _dc.forward
  921.                                 ((i + 1) + "Y", (i + 2) + "Y")))
  922.                                 return false;
  923.                         } catch (java.lang.Exception e) {
  924.                             e.printStackTrace();

  926.                             return false;
  927.                         }
  928.                     }

  930.                     return true;
  931.                 }

  933.                 @Override public boolean postRegression (
  934.                     final org.drip.regression.core.RegressionRunDetail rnvd)
  935.                 {
  936.                     for (int i = 0; i < NUM_DC_INSTRUMENTS; ++i) {
  937.                         try {
  938.                             rnvd.set ("ImpliedRate[" + new org.drip.analytics.date.JulianDate (_aiDate[i])
  939.                                 + "]", org.drip.numerical.common.FormatUtil.FormatDouble (_adblImpliedRate[i], 1,
  940.                                     4, 1));
  941.                         } catch (java.lang.Exception e) {
  942.                             e.printStackTrace();

  944.                             return false;
  945.                         }
  946.                     }

  948.                     return true;
  949.                 }
  950.             });
  951.         } catch (java.lang.Exception e) {
  952.             e.printStackTrace();

  954.             return false;
  955.         }

  957.         return true;
  958.     }

  960.     @Override public java.util.List<org.drip.regression.core.UnitRegressor> getRegressorSet()
  961.     {
  962.         return _setRegressors;
  963.     }

  965.     @Override public java.lang.String getSetName()
  966.     {
  967.         return _strRegressionScenario;
  968.     }
  969. }
Created with JaCoCo 0.7.9.201702052155