MonotoneConvexHaganWest.java

  1. package org.drip.spline.pchip;

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

  83. /**
  84.  * <i>MonotoneConvexHaganWest</i> implements the regime using the Hagan and West (2006) Estimator. It
  85.  * provides the following functionality:
  86.  *
  87.  * <br><br>
  88.  *  <ul>
  89.  *      <li>
  90.  *          Static Method to Create an instance of MonotoneConvexHaganWest
  91.  *      </li>
  92.  *      <li>
  93.  *          Ensure that the estimated regime is monotone an convex
  94.  *      </li>
  95.  *      <li>
  96.  *          If need be, enforce positivity and/or apply amelioration
  97.  *      </li>
  98.  *      <li>
  99.  *          Apply segment-by-segment range bounds as needed
  100.  *      </li>
  101.  *      <li>
  102.  *          Retrieve predictor ordinates/response values
  103.  *      </li>
  104.  *  </ul>
  105.  *
  106.  * <br><br>
  107.  *  <ul>
  108.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  109.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/SplineBuilderLibrary.md">Spline Builder Library</a></li>
  110.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spline/README.md">Basis Splines and Linear Compounders across a Broad Family of Spline Basis Functions</a></li>
  111.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spline/pchip/README.md">Monotone Convex Themed PCHIP Splines</a></li>
  112.  *  </ul>
  113.  * <br><br>
  114.  *
  115.  * @author Lakshmi Krishnamurthy
  116.  */

  118. public class MonotoneConvexHaganWest extends org.drip.function.definition.R1ToR1 {
  119.     private double[] _adblObservation = null;
  120.     private double[] _adblResponseValue = null;
  121.     private boolean _bLinearNodeInference = true;
  122.     private double[] _adblPredictorOrdinate = null;
  123.     private double[] _adblResponseZScoreLeft = null;
  124.     private double[] _adblResponseZScoreRight = null;
  125.     private org.drip.function.definition.R1ToR1[] _aAU = null;

  127.     class Case1Univariate extends org.drip.function.definition.R1ToR1 {
  128.         private double _dblResponseZScoreLeft = java.lang.Double.NaN;
  129.         private double _dblResponseZScoreRight = java.lang.Double.NaN;
  130.         private double _dblPredictorOrdinateLeft = java.lang.Double.NaN;
  131.         private double _dblPredictorOrdinateRight = java.lang.Double.NaN;

  133.         Case1Univariate (
  134.             final double dblPredictorOrdinateLeft,
  135.             final double dblPredictorOrdinateRight,
  136.             final double dblResponseZScoreLeft,
  137.             final double dblResponseZScoreRight)
  138.         {
  139.             super (null);

  141.             _dblResponseZScoreLeft = dblResponseZScoreLeft;
  142.             _dblResponseZScoreRight = dblResponseZScoreRight;
  143.             _dblPredictorOrdinateLeft = dblPredictorOrdinateLeft;
  144.             _dblPredictorOrdinateRight = dblPredictorOrdinateRight;
  145.         }

  147.         @Override public double evaluate (
  148.             final double dblPredictorOrdinate)
  149.             throws java.lang.Exception
  150.         {
  151.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate) || dblPredictorOrdinate <
  152.                 _dblPredictorOrdinateLeft || dblPredictorOrdinate > _dblPredictorOrdinateRight)
  153.                 throw new java.lang.Exception ("Case1Univariate::evaluate => Invalid Inputs");

  155.             double dblX = (dblPredictorOrdinate - _dblPredictorOrdinateLeft) / (_dblPredictorOrdinateRight -
  156.                 _dblPredictorOrdinateLeft);
  157.             return _dblResponseZScoreLeft * (1. - 4. * dblX + 3. * dblX * dblX) + _dblResponseZScoreRight *
  158.                 (-2. * dblX + 3. * dblX * dblX);
  159.         }

  161.         @Override public double integrate (
  162.             final double dblBegin,
  163.             final double dblEnd)
  164.             throws java.lang.Exception
  165.         {
  166.             return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  167.         }
  168.     }

  170.     class Case2Univariate extends org.drip.function.definition.R1ToR1 {
  171.         private double _dblEta = java.lang.Double.NaN;
  172.         private double _dblResponseZScoreLeft = java.lang.Double.NaN;
  173.         private double _dblResponseZScoreRight = java.lang.Double.NaN;
  174.         private double _dblPredictorOrdinateLeft = java.lang.Double.NaN;
  175.         private double _dblPredictorOrdinateRight = java.lang.Double.NaN;

  177.         Case2Univariate (
  178.             final double dblPredictorOrdinateLeft,
  179.             final double dblPredictorOrdinateRight,
  180.             final double dblResponseZScoreLeft,
  181.             final double dblResponseZScoreRight)
  182.         {
  183.             super (null);

  185.             _dblResponseZScoreLeft = dblResponseZScoreLeft;
  186.             _dblResponseZScoreRight = dblResponseZScoreRight;
  187.             _dblPredictorOrdinateLeft = dblPredictorOrdinateLeft;
  188.             _dblPredictorOrdinateRight = dblPredictorOrdinateRight;
  189.             _dblEta = _dblResponseZScoreLeft != _dblResponseZScoreRight ? (_dblResponseZScoreRight + 2. *
  190.                 _dblResponseZScoreLeft) / (_dblResponseZScoreRight - _dblResponseZScoreLeft) : 0.;
  191.         }

  193.         @Override public double evaluate (
  194.             final double dblPredictorOrdinate)
  195.             throws java.lang.Exception
  196.         {
  197.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate) || dblPredictorOrdinate <
  198.                 _dblPredictorOrdinateLeft || dblPredictorOrdinate > _dblPredictorOrdinateRight)
  199.                 throw new java.lang.Exception ("Case2Univariate::evaluate => Invalid Inputs");

  201.             if (_dblResponseZScoreLeft == _dblResponseZScoreRight) return _dblResponseZScoreRight;

  203.             double dblX = (dblPredictorOrdinate - _dblPredictorOrdinateLeft) / (_dblPredictorOrdinateRight -
  204.                 _dblPredictorOrdinateLeft);
  205.             return dblX <= _dblEta ? _dblResponseZScoreLeft : _dblResponseZScoreLeft +
  206.                 (_dblResponseZScoreRight - _dblResponseZScoreLeft) * (dblX - _dblEta) * (dblX - _dblEta) /
  207.                     (1. - _dblEta) / (1. - _dblEta);
  208.         }

  210.         @Override public double integrate (
  211.             final double dblBegin,
  212.             final double dblEnd)
  213.             throws java.lang.Exception
  214.         {
  215.             return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  216.         }
  217.     }

  219.     class Case3Univariate extends org.drip.function.definition.R1ToR1 {
  220.         private double _dblEta = java.lang.Double.NaN;
  221.         private double _dblResponseZScoreLeft = java.lang.Double.NaN;
  222.         private double _dblResponseZScoreRight = java.lang.Double.NaN;
  223.         private double _dblPredictorOrdinateLeft = java.lang.Double.NaN;
  224.         private double _dblPredictorOrdinateRight = java.lang.Double.NaN;

  226.         Case3Univariate (
  227.             final double dblPredictorOrdinateLeft,
  228.             final double dblPredictorOrdinateRight,
  229.             final double dblResponseZScoreLeft,
  230.             final double dblResponseZScoreRight)
  231.         {
  232.             super (null);

  234.             _dblResponseZScoreLeft = dblResponseZScoreLeft;
  235.             _dblResponseZScoreRight = dblResponseZScoreRight;
  236.             _dblPredictorOrdinateLeft = dblPredictorOrdinateLeft;
  237.             _dblPredictorOrdinateRight = dblPredictorOrdinateRight;
  238.             _dblEta = _dblResponseZScoreLeft != _dblResponseZScoreRight ? 3. * _dblResponseZScoreRight /
  239.                 (_dblResponseZScoreRight - _dblResponseZScoreLeft) : 0.;
  240.         }

  242.         @Override public double evaluate (
  243.             final double dblPredictorOrdinate)
  244.             throws java.lang.Exception
  245.         {
  246.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate) || dblPredictorOrdinate <
  247.                 _dblPredictorOrdinateLeft || dblPredictorOrdinate > _dblPredictorOrdinateRight)
  248.                 throw new java.lang.Exception ("Case3Univariate::evaluate => Invalid Inputs");

  250.             if (_dblResponseZScoreLeft == _dblResponseZScoreRight) return _dblResponseZScoreRight;

  252.             double dblX = (dblPredictorOrdinate - _dblPredictorOrdinateLeft) / (_dblPredictorOrdinateRight -
  253.                 _dblPredictorOrdinateLeft);
  254.             return dblX < _dblEta ? _dblResponseZScoreLeft + (_dblResponseZScoreLeft -
  255.                 _dblResponseZScoreRight) * (_dblEta - dblX) * (_dblEta - dblX) / _dblEta / _dblEta :
  256.                     _dblResponseZScoreRight;
  257.         }

  259.         @Override public double integrate (
  260.             final double dblBegin,
  261.             final double dblEnd)
  262.             throws java.lang.Exception
  263.         {
  264.             return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  265.         }
  266.     }

  268.     class Case4Univariate extends org.drip.function.definition.R1ToR1 {
  269.         private double _dblA = java.lang.Double.NaN;
  270.         private double _dblEta = java.lang.Double.NaN;
  271.         private double _dblResponseZScoreLeft = java.lang.Double.NaN;
  272.         private double _dblResponseZScoreRight = java.lang.Double.NaN;
  273.         private double _dblPredictorOrdinateLeft = java.lang.Double.NaN;
  274.         private double _dblPredictorOrdinateRight = java.lang.Double.NaN;

  276.         Case4Univariate (
  277.             final double dblPredictorOrdinateLeft,
  278.             final double dblPredictorOrdinateRight,
  279.             final double dblResponseZScoreLeft,
  280.             final double dblResponseZScoreRight)
  281.         {
  282.             super (null);

  284.             _dblResponseZScoreLeft = dblResponseZScoreLeft;
  285.             _dblResponseZScoreRight = dblResponseZScoreRight;
  286.             _dblPredictorOrdinateLeft = dblPredictorOrdinateLeft;
  287.             _dblPredictorOrdinateRight = dblPredictorOrdinateRight;

  289.             if (_dblResponseZScoreLeft != _dblResponseZScoreRight) {
  290.                 _dblEta = _dblResponseZScoreRight / (_dblResponseZScoreRight - _dblResponseZScoreLeft);
  291.                 _dblA = -1. * _dblResponseZScoreLeft * _dblResponseZScoreRight / (_dblResponseZScoreRight -
  292.                     _dblResponseZScoreLeft);
  293.             } else {
  294.                 _dblA = 0.;
  295.                 _dblEta = 0.;
  296.             }
  297.         }

  299.         @Override public double evaluate (
  300.             final double dblPredictorOrdinate)
  301.             throws java.lang.Exception
  302.         {
  303.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate) || dblPredictorOrdinate <
  304.                 _dblPredictorOrdinateLeft || dblPredictorOrdinate > _dblPredictorOrdinateRight)
  305.                 throw new java.lang.Exception ("Case4Univariate::evaluate => Invalid Inputs");

  307.             if (_dblResponseZScoreLeft == _dblResponseZScoreRight) return _dblResponseZScoreRight;

  309.             double dblX = (dblPredictorOrdinate - _dblPredictorOrdinateLeft) / (_dblPredictorOrdinateRight -
  310.                 _dblPredictorOrdinateLeft);
  311.             return dblX < _dblEta ? _dblA + (_dblResponseZScoreLeft - _dblA) * (_dblEta - dblX) * (_dblEta -
  312.                 dblX) / _dblEta / _dblEta : _dblA + (_dblResponseZScoreRight - _dblA) * (dblX - _dblEta) *
  313.                     (dblX - _dblEta) / (1. - _dblEta) / (1. - _dblEta);
  314.         }

  316.         @Override public double integrate (
  317.             final double dblBegin,
  318.             final double dblEnd)
  319.             throws java.lang.Exception
  320.         {
  321.             return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  322.         }
  323.     }

  325.     /**
  326.      * Create an instance of MonotoneConvexHaganWest
  327.      * 
  328.      * @param adblPredictorOrdinate Array of Predictor Ordinates
  329.      * @param adblObservation Array of Observations
  330.      * @param bLinearNodeInference Apply Linear Node Inference from Observations
  331.      * 
  332.      * @return Instance of MonotoneConvexHaganWest
  333.      */

  335.     public static final MonotoneConvexHaganWest Create (
  336.         final double[] adblPredictorOrdinate,
  337.         final double[] adblObservation,
  338.         final boolean bLinearNodeInference)
  339.     {
  340.         MonotoneConvexHaganWest mchw = null;

  342.         try {
  343.             mchw = new MonotoneConvexHaganWest (adblPredictorOrdinate, adblObservation,
  344.                 bLinearNodeInference);
  345.         } catch (java.lang.Exception e) {
  346.             e.printStackTrace();

  348.             return null;
  349.         }

  351.         return mchw.inferResponseValues() && mchw.inferResponseZScores() && mchw.generateUnivariate() ? mchw
  352.             : null;
  353.     }

  355.     private MonotoneConvexHaganWest (
  356.         final double[] adblPredictorOrdinate,
  357.         final double[] adblObservation,
  358.         final boolean bLinearNodeInference)
  359.         throws java.lang.Exception
  360.     {
  361.         super (null);

  363.         if (null == (_adblObservation = adblObservation) || null == (_adblPredictorOrdinate =
  364.             adblPredictorOrdinate))
  365.             throw new java.lang.Exception ("MonotoneConvexHaganWest ctr: Invalid Inputs!");

  367.         _bLinearNodeInference = bLinearNodeInference;
  368.         int iNumObservation = _adblObservation.length;

  370.         if (1 >= iNumObservation || iNumObservation + 1 != _adblPredictorOrdinate.length)
  371.             throw new java.lang.Exception ("MonotoneConvexHaganWest ctr: Invalid Inputs!");
  372.     }

  374.     private boolean inferResponseValues()
  375.     {
  376.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;
  377.         _adblResponseValue = new double[iNumPredictorOrdinate];

  379.         for (int i = 1; i < iNumPredictorOrdinate - 1; ++i) {
  380.             if (_bLinearNodeInference)
  381.                 _adblResponseValue[i] = (_adblPredictorOrdinate[i] - _adblPredictorOrdinate[i - 1]) /
  382.                     (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i - 1]) * _adblObservation[i] +
  383.                         (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i]) /
  384.                             (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i - 1]) *
  385.                                 _adblObservation[i - 1];
  386.             else {
  387.                 _adblResponseValue[i] = 0.;

  389.                 if (_adblObservation[i - 1] * _adblObservation[i] > 0.) {
  390.                     _adblResponseValue[i] = (_adblPredictorOrdinate[i] - _adblPredictorOrdinate[i - 1] + 2. *
  391.                         (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i])) / (3. *
  392.                             (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i])) /
  393.                                 _adblObservation[i - 1];
  394.                     _adblResponseValue[i] += (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i] + 2.
  395.                         * (_adblPredictorOrdinate[i] - _adblPredictorOrdinate[i - 1])) / (3. *
  396.                             (_adblPredictorOrdinate[i + 1] - _adblPredictorOrdinate[i])) /
  397.                                 _adblObservation[i];
  398.                     _adblResponseValue[i] = 1. / _adblResponseValue[i];
  399.                 }
  400.             }
  401.         }

  403.         _adblResponseValue[0] = _adblObservation[0] - 0.5 * (_adblResponseValue[1] - _adblObservation[0]);
  404.         _adblResponseValue[iNumPredictorOrdinate - 1] = _adblObservation[iNumPredictorOrdinate - 2] - 0.5 *
  405.             (_adblResponseValue[iNumPredictorOrdinate - 2] - _adblObservation[iNumPredictorOrdinate - 2]);
  406.         return true;
  407.     }

  409.     private boolean inferResponseZScores()
  410.     {
  411.         int iNumSegment = _adblPredictorOrdinate.length - 1;
  412.         _adblResponseZScoreLeft = new double[iNumSegment];
  413.         _adblResponseZScoreRight = new double[iNumSegment];

  415.         for (int i = 0; i < iNumSegment; ++i) {
  416.             _adblResponseZScoreLeft[i] = _adblResponseValue[i] - _adblObservation[i];
  417.             _adblResponseZScoreRight[i] = _adblResponseValue[i + 1] - _adblObservation[i];
  418.         }

  420.         return true;
  421.     }

  423.     private boolean generateUnivariate()
  424.     {
  425.         int iNumSegment = _adblPredictorOrdinate.length - 1;
  426.         _aAU = new org.drip.function.definition.R1ToR1[iNumSegment];

  428.         for (int i = 0; i < iNumSegment; ++i) {
  429.             if ((_adblResponseZScoreLeft[i] > 0. && -0.5 * _adblResponseZScoreLeft[i] >=
  430.                 _adblResponseZScoreRight[i] && _adblResponseZScoreRight[i] >= -2. *
  431.                     _adblResponseZScoreLeft[i]) || (_adblResponseZScoreLeft[i] < 0. && -0.5 *
  432.                         _adblResponseZScoreLeft[i] <= _adblResponseZScoreRight[i] &&
  433.                             _adblResponseZScoreRight[i] <= -2. * _adblResponseZScoreLeft[i]))
  434.                 _aAU[i] = new Case1Univariate (_adblPredictorOrdinate[i], _adblPredictorOrdinate[i + 1],
  435.                     _adblResponseZScoreLeft[i], _adblResponseZScoreRight[i]);
  436.             else if ((_adblResponseZScoreLeft[i] < 0. && _adblResponseZScoreRight[i] > -2. *
  437.                 _adblResponseZScoreLeft[i]) || (_adblResponseZScoreLeft[i] > 0. &&
  438.                     _adblResponseZScoreRight[i] < -2. * _adblResponseZScoreLeft[i]))
  439.                 _aAU[i] = new Case2Univariate (_adblPredictorOrdinate[i], _adblPredictorOrdinate[i + 1],
  440.                     _adblResponseZScoreLeft[i], _adblResponseZScoreRight[i]);
  441.             else if ((_adblResponseZScoreLeft[i] > 0. && _adblResponseZScoreRight[i] > -0.5 *
  442.                 _adblResponseZScoreLeft[i]) || (_adblResponseZScoreLeft[i] < 0. &&
  443.                     _adblResponseZScoreRight[i] < -0.5 * _adblResponseZScoreLeft[i]))
  444.                 _aAU[i] = new Case3Univariate (_adblPredictorOrdinate[i], _adblPredictorOrdinate[i + 1],
  445.                     _adblResponseZScoreLeft[i], _adblResponseZScoreRight[i]);
  446.             else if ((_adblResponseZScoreLeft[i] >= 0. && _adblResponseZScoreRight[i] >= 0.) ||
  447.                 (_adblResponseZScoreLeft[i] <= 0. && _adblResponseZScoreRight[i] <= 0.))
  448.                 _aAU[i] = new Case4Univariate (_adblPredictorOrdinate[i], _adblPredictorOrdinate[i + 1],
  449.                     _adblResponseZScoreLeft[i], _adblResponseZScoreRight[i]);
  450.         }

  452.         return true;
  453.     }

  455.     private boolean ameliorate (
  456.         final double[] adblResponseLeftMin,
  457.         final double[] adblResponseLeftMax,
  458.         final double[] adblResponseRightMin,
  459.         final double[] adblResponseRightMax)
  460.     {
  461.         int iNumObservation = _adblObservation.length;

  463.         if (iNumObservation != adblResponseLeftMin.length || iNumObservation != adblResponseLeftMax.length ||
  464.             iNumObservation != adblResponseRightMin.length || iNumObservation != adblResponseRightMax.length)
  465.             return false;

  467.         for (int i = 0; i < iNumObservation; ++i) {
  468.             if (_adblResponseValue[i] < java.lang.Math.max (adblResponseLeftMin[i], adblResponseRightMin[i])
  469.                 || _adblResponseValue[i] > java.lang.Math.min (adblResponseLeftMax[i],
  470.                     adblResponseRightMax[i])) {
  471.                 if (_adblResponseValue[i] < java.lang.Math.max (adblResponseLeftMin[i],
  472.                     adblResponseRightMin[i]))
  473.                     _adblResponseValue[i] = java.lang.Math.max (adblResponseLeftMin[i],
  474.                         adblResponseRightMin[i]);
  475.                 else if (_adblResponseValue[i] > java.lang.Math.min (adblResponseLeftMax[i],
  476.                     adblResponseRightMax[i]))
  477.                     _adblResponseValue[i] = java.lang.Math.min (adblResponseLeftMax[i],
  478.                         adblResponseRightMax[i]);
  479.             } else {
  480.                 if (_adblResponseValue[i] < java.lang.Math.min (adblResponseLeftMax[i],
  481.                     adblResponseRightMax[i]))
  482.                     _adblResponseValue[i] = java.lang.Math.min (adblResponseLeftMax[i],
  483.                         adblResponseRightMax[i]);
  484.                 else if (_adblResponseValue[i] > java.lang.Math.max (adblResponseLeftMin[i],
  485.                     adblResponseRightMin[i]))
  486.                     _adblResponseValue[i] = java.lang.Math.max (adblResponseLeftMin[i],
  487.                         adblResponseRightMin[i]);
  488.             }
  489.         }

  491.         if (java.lang.Math.abs (_adblResponseValue[0] - _adblObservation[0]) > 0.5 * java.lang.Math.abs
  492.             (_adblResponseValue[1] - _adblObservation[0]))
  493.             _adblResponseValue[0] = _adblObservation[1] - 0.5 * (_adblResponseValue[1] -
  494.                 _adblObservation[0]);

  496.         if (java.lang.Math.abs (_adblResponseValue[iNumObservation] - _adblObservation[iNumObservation - 1])
  497.             > 0.5 * java.lang.Math.abs (_adblResponseValue[iNumObservation - 1] -
  498.                 _adblObservation[iNumObservation - 1]))
  499.             _adblResponseValue[iNumObservation] = _adblObservation[iNumObservation - 1] - 0.5 *
  500.                 (_adblObservation[iNumObservation - 1] - _adblResponseValue[iNumObservation - 1]);

  502.         return inferResponseZScores() && generateUnivariate();
  503.     }

  505.     private int containingIndex (
  506.         final double dblPredictorOrdinate,
  507.         final boolean bIncludeLeft,
  508.         final boolean bIncludeRight)
  509.         throws java.lang.Exception
  510.     {
  511.         int iNumSegment = _aAU.length;

  513.         for (int i = 0 ; i < iNumSegment; ++i) {
  514.             boolean bLeftValid = bIncludeLeft ? _adblPredictorOrdinate[i] <= dblPredictorOrdinate :
  515.                 _adblPredictorOrdinate[i] < dblPredictorOrdinate;

  517.             boolean bRightValid = bIncludeRight ? _adblPredictorOrdinate[i + 1] >= dblPredictorOrdinate :
  518.                 _adblPredictorOrdinate[i + 1] > dblPredictorOrdinate;

  520.             if (bLeftValid && bRightValid) return i;
  521.         }

  523.         throw new java.lang.Exception
  524.             ("MonotoneConvexHaganWest::containingIndex => Cannot locate Containing Index");
  525.     }

  527.     @Override public double evaluate (
  528.         final double dblPredictorOrdinate)
  529.         throws java.lang.Exception
  530.     {
  531.         int iContainingIndex = containingIndex (dblPredictorOrdinate, true, true);

  533.         return _aAU[iContainingIndex].evaluate (dblPredictorOrdinate) + _adblObservation[iContainingIndex];
  534.     }

  536.     /**
  537.      * Enforce the Positivity of the Inferred Response Values
  538.      * 
  539.      * @return TRUE - Positivity Enforcement is successful
  540.      */

  542.     public boolean enforcePositivity()
  543.     {
  544.         try {
  545.             _adblResponseValue[0] = org.drip.numerical.common.NumberUtil.Bound (_adblResponseValue[0], 0., 2. *
  546.                 _adblObservation[0]);

  548.             int iNumObservation = _adblObservation.length;

  550.             for (int i = 1; i < iNumObservation; ++i)
  551.                 _adblResponseValue[i] = org.drip.numerical.common.NumberUtil.Bound (_adblResponseValue[i], 0., 2.
  552.                     * java.lang.Math.min (_adblObservation[i - 1], _adblObservation[i]));

  554.             _adblResponseValue[iNumObservation] = org.drip.numerical.common.NumberUtil.Bound
  555.                 (_adblResponseValue[iNumObservation], 0., 2. * _adblObservation[iNumObservation - 1]);

  557.             return inferResponseZScores() && generateUnivariate();
  558.         } catch (java.lang.Exception e) {
  559.             e.printStackTrace();
  560.         }

  562.         return false;
  563.     }

  565.     /**
  566.      * Create an Ameliorated Instance of the Current Instance
  567.      * 
  568.      * @param adblResponseLeftMin Response Left Floor
  569.      * @param adblResponseLeftMax Response Left Ceiling
  570.      * @param adblResponseRightMin Response Right Floor
  571.      * @param adblResponseRightMax Response Right Ceiling
  572.      * @param bEnforcePositivity TRUE - Enforce Positivity
  573.      * 
  574.      * @return The Ameliorated Version of the Current Instance
  575.      */

  577.     public MonotoneConvexHaganWest generateAmelioratedInstance (
  578.         final double[] adblResponseLeftMin,
  579.         final double[] adblResponseLeftMax,
  580.         final double[] adblResponseRightMin,
  581.         final double[] adblResponseRightMax,
  582.         final boolean bEnforcePositivity)
  583.     {
  584.         if (null == adblResponseLeftMin || null == adblResponseLeftMax | null == adblResponseRightMin || null
  585.             == adblResponseRightMax)
  586.             return null;

  588.         int iNumAmelioratedObservation = _adblObservation.length + 2;
  589.         int iNumAmelioratedPredicatorOrdinate = _adblPredictorOrdinate.length + 2;
  590.         double[] adblAmelioratedObservation = new double[iNumAmelioratedObservation];
  591.         double[] adblAmelioratedPredictorOrdinate = new double[iNumAmelioratedPredicatorOrdinate];

  593.         for (int i = 0; i < iNumAmelioratedPredicatorOrdinate; ++i) {
  594.             if (0 == i)
  595.                 adblAmelioratedPredictorOrdinate[0] = -1. * _adblPredictorOrdinate[1];
  596.             else if (iNumAmelioratedPredicatorOrdinate - 1 == i)
  597.                 adblAmelioratedPredictorOrdinate[i] = 2. * _adblPredictorOrdinate[i - 1] -
  598.                     _adblPredictorOrdinate[i - 2];
  599.             else
  600.                 adblAmelioratedPredictorOrdinate[i] = _adblPredictorOrdinate[i - 1];
  601.         }

  603.         for (int i = 0; i < iNumAmelioratedObservation; ++i) {
  604.             if (0 == i)
  605.                 adblAmelioratedObservation[0] = _adblObservation[0] - (_adblPredictorOrdinate[1] -
  606.                     _adblPredictorOrdinate[0]) * (_adblObservation[1] - _adblObservation[0]) /
  607.                         (_adblPredictorOrdinate[2] - _adblPredictorOrdinate[0]);
  608.             else if (iNumAmelioratedPredicatorOrdinate - 1 == i)
  609.                 adblAmelioratedObservation[i] = _adblObservation[i - 1] - (_adblPredictorOrdinate[i - 1] -
  610.                     _adblPredictorOrdinate[i - 2]) * (_adblObservation[i - 1] - _adblObservation[i - 2]) /
  611.                         (_adblPredictorOrdinate[i - 1] - _adblPredictorOrdinate[i - 3]);
  612.             else
  613.                 adblAmelioratedObservation[i] = _adblObservation[i - 1];
  614.         }

  616.         MonotoneConvexHaganWest mchwAmeliorated = Create (adblAmelioratedPredictorOrdinate,
  617.             adblAmelioratedObservation, _bLinearNodeInference);

  619.         if (null == mchwAmeliorated || mchwAmeliorated.ameliorate (adblResponseLeftMin, adblResponseLeftMax,
  620.             adblResponseRightMin, adblResponseRightMax))
  621.             return null;

  623.         if (bEnforcePositivity) {
  624.             if (!mchwAmeliorated.enforcePositivity()) return null;
  625.         }

  627.         return mchwAmeliorated;
  628.     }

  630.     /**
  631.      * Retrieve the Array of Predictor Ordinates
  632.      * 
  633.      * @return The Array of Predictor Ordinates
  634.      */

  636.     public double[] predictorOrdinates()
  637.     {
  638.         return _adblPredictorOrdinate;
  639.     }

  641.     /**
  642.      * Retrieve the Array of Response Values
  643.      * 
  644.      * @return The Array of Response Values
  645.      */

  647.     public double[] responseValues()
  648.     {
  649.         return _adblResponseValue;
  650.     }
  651. }
Created with JaCoCo 0.7.9.201702052155