LocalMonotoneCkGenerator.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>LocalMonotoneCkGenerator</i> generates customized Local Stretch by trading off Ck for local control.
  85.  * This class implements the following variants: Akima, Bessel, Harmonic, Hyman83, Hyman89, Kruger, Monotone
  86.  * Convex, as well as the Van Leer and the Huynh/LeFloch limiters. It also provides the following custom
  87.  * control on the resulting C1:
  88.  *
  89.  * <br><br>
  90.  *  <ul>
  91.  *      <li>
  92.  *          Eliminate the Spurious Extrema in the Input C1 Entry
  93.  *      </li>
  94.  *      <li>
  95.  *          Apply the Monotone Filter in the Input C1 Entry
  96.  *      </li>
  97.  *      <li>
  98.  *          Generate a Vanilla C1 Array from the specified Array of Predictor Ordinates and the Response
  99.  *              Values
  100.  *      </li>
  101.  *      <li>
  102.  *          Verify if the given Quintic Polynomial is Monotone using the Hyman89 Algorithm, and generate it
  103.  *              if necessary
  104.  *      </li>
  105.  *  </ul>
  106.  *
  107.  * <br><br>
  108.  *  <ul>
  109.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  110.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/SplineBuilderLibrary.md">Spline Builder Library</a></li>
  111.  *      <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>
  112.  *      <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>
  113.  *  </ul>
  114.  * <br><br>
  115.  *
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class LocalMonotoneCkGenerator {

  121.     /**
  122.      * C1 Type: Vanilla
  123.      */

  125.     public static final java.lang.String C1_VANILLA = "C1_VANILLA";

  127.     /**
  128.      * C1 Type: Akima
  129.      */

  131.     public static final java.lang.String C1_AKIMA = "C1_AKIMA";

  133.     /**
  134.      * C1 Type: Bessel
  135.      */

  137.     public static final java.lang.String C1_BESSEL = "C1_BESSEL";

  139.     /**
  140.      * C1 Type: Harmonic
  141.      */

  143.     public static final java.lang.String C1_HARMONIC = "C1_HARMONIC";

  145.     /**
  146.      * C1 Type: Huynh - Le Floch Limiter
  147.      */

  149.     public static final java.lang.String C1_HUYNH_LE_FLOCH = "C1_HUYNH_LE_FLOCH";

  151.     /**
  152.      * C1 Type: Hyman83
  153.      */

  155.     public static final java.lang.String C1_HYMAN83 = "C1_HYMAN83";

  157.     /**
  158.      * C1 Type: Hyman89
  159.      */

  161.     public static final java.lang.String C1_HYMAN89 = "C1_HYMAN89";

  163.     /**
  164.      * C1 Type: Kruger
  165.      */

  167.     public static final java.lang.String C1_KRUGER = "C1_KRUGER";

  169.     /**
  170.      * C1 Type: Monotone Convex
  171.      */

  173.     public static final java.lang.String C1_MONOTONE_CONVEX = "C1_MONOTONE_CONVEX";

  175.     /**
  176.      * C1 Type: Van Leer Limiter
  177.      */

  179.     public static final java.lang.String C1_VAN_LEER = "C1_VAN_LEER";

  181.     private double[] _adblC1 = null;
  182.     private double[] _adblResponseValue = null;
  183.     private double[] _adblPredictorOrdinate = null;

  185.     /**
  186.      * Eliminate the Spurious Extrema in the Input C1 Entry
  187.      * 
  188.      * @param adblC1 The C1 Array in which the Spurious Extrema is to be eliminated
  189.      * @param adblLinearC1 Array of the Linear C1 Entries
  190.      * 
  191.      * @return The C1 Array with the Spurious Extrema eliminated
  192.      */

  194.     public static final double[] EliminateSpuriousExtrema (
  195.         final double[] adblC1,
  196.         final double[] adblLinearC1)
  197.     {
  198.         if (null == adblC1 || null == adblLinearC1) return null;

  200.         int iNumEntries = adblC1.length;
  201.         double[] adblUpdatedC1 = new double[iNumEntries];
  202.         adblUpdatedC1[0] = adblC1[0];
  203.         adblUpdatedC1[iNumEntries - 1] = adblC1[iNumEntries - 1];

  205.         if (1 >= iNumEntries || iNumEntries != adblLinearC1.length + 1) return null;

  207.         for (int i = 1; i < iNumEntries - 1; ++i)
  208.             adblUpdatedC1[i] = 0. < adblLinearC1[i] ? java.lang.Math.min (java.lang.Math.max (0., adblC1[i]),
  209.                 java.lang.Math.min (adblLinearC1[i], adblLinearC1[i - 1])) : java.lang.Math.max
  210.                     (java.lang.Math.min (0., adblC1[i]), java.lang.Math.max (adblLinearC1[i],
  211.                         adblLinearC1[i - 1]));

  213.         return adblUpdatedC1;
  214.     }

  216.     /**
  217.      * Apply the Monotone Filter in the Input C1 Entry
  218.      * 
  219.      * @param adblC1 The C1 Array in which the Monotone Filter is to be applied
  220.      * @param adblLinearC1 Array of the Linear C1 Entries
  221.      * 
  222.      * @return The C1 Array with the Monotone Filter applied
  223.      */

  225.     public static final double[] ApplyMonotoneFilter (
  226.         final double[] adblC1,
  227.         final double[] adblLinearC1)
  228.     {
  229.         if (null == adblC1 || null == adblLinearC1) return null;

  231.         int iNumEntries = adblC1.length;
  232.         double[] adblUpdatedC1 = new double[iNumEntries];
  233.         adblUpdatedC1[0] = adblC1[0];

  235.         if (1 >= iNumEntries || iNumEntries != adblLinearC1.length + 1) return null;

  237.         for (int i = 0; i < iNumEntries; ++i) {
  238.             if (0 == i) {
  239.                 if (adblC1[0] * adblLinearC1[0] > 0. && adblLinearC1[0] * adblLinearC1[1] > 0. &&
  240.                     java.lang.Math.abs (adblC1[0]) < 3. * java.lang.Math.abs (adblLinearC1[0]))
  241.                     adblUpdatedC1[0] = 3. * adblLinearC1[0];
  242.                 else if (adblC1[0] * adblLinearC1[0] <= 0.)
  243.                     adblUpdatedC1[0] = 0.;
  244.             } else if (iNumEntries == i) {
  245.                 if (adblC1[i] * adblLinearC1[i - 1] > 0. && adblLinearC1[i - 1] * adblLinearC1[i - 2] > 0. &&
  246.                     java.lang.Math.abs (adblC1[i]) < 3. * java.lang.Math.abs (adblLinearC1[i - 1]))
  247.                     adblUpdatedC1[i] = 3. * adblLinearC1[i - 1];
  248.                 else if (adblC1[i] * adblLinearC1[i - 1] <= 0.)
  249.                     adblUpdatedC1[i] = 0.;
  250.             } else
  251.                 adblUpdatedC1[i] = adblC1[i];
  252.         }

  254.         return adblUpdatedC1;
  255.     }

  257.     /**
  258.      * Generate a Vanilla C1 Array from the specified Array of Predictor Ordinates and the Response Values
  259.      * 
  260.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  261.      * @param adblResponseValue The Response Value Array
  262.      * 
  263.      * @return The C1 Array
  264.      */

  266.     public static final double[] LinearC1 (
  267.         final double[] adblPredictorOrdinate,
  268.         final double[] adblResponseValue)
  269.     {
  270.         int iNumSegment = adblResponseValue.length - 1;
  271.         double[] adblLinearC1 = new double[iNumSegment];

  273.         for (int i = 0; i < iNumSegment; ++i)
  274.             adblLinearC1[i] = (adblResponseValue[i + 1] - adblResponseValue[i]) /
  275.                 (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i]);

  277.         return adblLinearC1;
  278.     }

  280.     /**
  281.      * Generate a Bessel C1 Array from the specified Array of Predictor Ordinates and the Response Values
  282.      * 
  283.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  284.      * @param adblResponseValue The Response Value Array
  285.      * 
  286.      * @return The C1 Array
  287.      */

  289.     public static final double[] BesselC1 (
  290.         final double[] adblPredictorOrdinate,
  291.         final double[] adblResponseValue)
  292.     {
  293.         int iNumResponse = adblResponseValue.length;
  294.         double[] adblBesselC1 = new double[iNumResponse];

  296.         for (int i = 0; i < iNumResponse; ++i) {
  297.             if (0 == i) {
  298.                 adblBesselC1[i] = (adblPredictorOrdinate[2] + adblPredictorOrdinate[1] - 2. *
  299.                     adblPredictorOrdinate[0]) * (adblResponseValue[1] - adblResponseValue[0]) /
  300.                         (adblPredictorOrdinate[1] - adblPredictorOrdinate[0]);
  301.                 adblBesselC1[i] -= (adblPredictorOrdinate[1] - adblPredictorOrdinate[0]) *
  302.                     (adblResponseValue[2] - adblResponseValue[1]) / (adblPredictorOrdinate[2] -
  303.                         adblPredictorOrdinate[1]);
  304.                 adblBesselC1[i] /= (adblPredictorOrdinate[2] - adblPredictorOrdinate[0]);
  305.             } else if (iNumResponse - 1 == i) {
  306.                 adblBesselC1[i] = (adblPredictorOrdinate[iNumResponse - 1] -
  307.                     adblPredictorOrdinate[iNumResponse - 2]) * (adblResponseValue[iNumResponse - 2] -
  308.                         adblResponseValue[iNumResponse - 3]) / (adblPredictorOrdinate[iNumResponse - 2] -
  309.                             adblPredictorOrdinate[iNumResponse - 3]);
  310.                 adblBesselC1[i] -= (2. * adblPredictorOrdinate[iNumResponse - 1] -
  311.                     adblPredictorOrdinate[iNumResponse - 2] - adblPredictorOrdinate[iNumResponse - 3]) *
  312.                         (adblResponseValue[iNumResponse - 1] - adblResponseValue[iNumResponse - 2]) /
  313.                             (adblPredictorOrdinate[iNumResponse - 1] -
  314.                                 adblPredictorOrdinate[iNumResponse - 2]);
  315.                 adblBesselC1[i] /= (adblPredictorOrdinate[iNumResponse - 1] -
  316.                     adblPredictorOrdinate[iNumResponse - 3]);
  317.             } else {
  318.                 adblBesselC1[i] = (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i]) *
  319.                     (adblResponseValue[i] - adblResponseValue[i - 1]) / (adblPredictorOrdinate[i] -
  320.                         adblPredictorOrdinate[i - 1]);
  321.                 adblBesselC1[i] += (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]) *
  322.                     (adblResponseValue[i + 1] - adblResponseValue[i]) / (adblPredictorOrdinate[i + 1] -
  323.                         adblPredictorOrdinate[i]);
  324.                 adblBesselC1[i] /= (adblPredictorOrdinate[iNumResponse - 1] -
  325.                     adblPredictorOrdinate[iNumResponse - 3]);
  326.             }
  327.         }

  329.         return adblBesselC1;
  330.     }

  332.     /**
  333.      * Generate a Hyman83 C1 Array from the specified Array of Predictor Ordinates and the Response Values
  334.      * 
  335.      *  Hyman (1983) Accurate Monotonicity Preserving Cubic Interpolation -
  336.      *      SIAM J on Numerical Analysis 4 (4), 645-654.
  337.      * 
  338.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  339.      * @param adblResponseValue The Response Value Array
  340.      * 
  341.      * @return The C1 Array
  342.      */

  344.     public static final double[] Hyman83C1 (
  345.         final double[] adblPredictorOrdinate,
  346.         final double[] adblResponseValue)
  347.     {
  348.         int iNumResponse = adblResponseValue.length;
  349.         double dblLinearSlopePrev = java.lang.Double.NaN;
  350.         double[] adblHyman83C1 = new double[iNumResponse];

  352.         for (int i = 0; i < iNumResponse; ++i) {
  353.             adblHyman83C1[i] = 0.;
  354.             double dblLinearSlope = iNumResponse - 1 != i ? (adblResponseValue[i + 1] - adblResponseValue[i])
  355.                 / (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i]) : java.lang.Double.NaN;

  357.             if (0 != i && iNumResponse - 1 != i) {
  358.                 double dblMonotoneIndicator = dblLinearSlopePrev * dblLinearSlope;

  360.                 if (0. <= dblMonotoneIndicator)
  361.                     adblHyman83C1[i] = 3. * dblMonotoneIndicator / (java.lang.Math.max (dblLinearSlope,
  362.                         dblLinearSlopePrev) + 2. * java.lang.Math.min (dblLinearSlope, dblLinearSlopePrev));
  363.             }

  365.             dblLinearSlopePrev = dblLinearSlope;
  366.         }

  368.         return adblHyman83C1;
  369.     }

  371.     /**
  372.      * Generate a Hyman89 C1 Array from the specified Array of Predictor Ordinates and the Response Values
  373.      * 
  374.      *  Doherty, Edelman, and Hyman (1989) Non-negative, monotonic, or convexity preserving cubic and quintic
  375.      *      Hermite interpolation - Mathematics of Computation 52 (186), 471-494.
  376.      * 
  377.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  378.      * @param adblResponseValue The Response Value Array
  379.      * 
  380.      * @return The C1 Array
  381.      */

  383.     public static final double[] Hyman89C1 (
  384.         final double[] adblPredictorOrdinate,
  385.         final double[] adblResponseValue)
  386.     {
  387.         int iNumResponse = adblResponseValue.length;
  388.         double[] adblHyman89C1 = new double[iNumResponse];

  390.         double[] adblNodeC1 = LinearC1 (adblPredictorOrdinate, adblResponseValue);

  392.         double[] adblBesselC1 = BesselC1 (adblPredictorOrdinate, adblResponseValue);

  394.         for (int i = 0; i < iNumResponse; ++i) {
  395.             if (i < 2 || i >= iNumResponse - 2)
  396.                 adblHyman89C1[i] = adblBesselC1[i];
  397.             else {
  398.                 double dMuMinus = (adblNodeC1[i - 1] * (2. * (adblPredictorOrdinate[i] -
  399.                     adblPredictorOrdinate[i - 1]) + adblPredictorOrdinate[i - 1] -
  400.                         adblPredictorOrdinate[i - 2]) - adblNodeC1[i - 2] * (adblPredictorOrdinate[i] -
  401.                             adblPredictorOrdinate[i - 1])) / (adblPredictorOrdinate[i] -
  402.                                 adblPredictorOrdinate[i - 2]);
  403.                 double dMu0 = (adblNodeC1[i - 1] * (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i])
  404.                     + adblNodeC1[i] * (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1])) /
  405.                         (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i - 1]);
  406.                 double dMuPlus = (adblNodeC1[i] * (2. * (adblPredictorOrdinate[i + 1] -
  407.                     adblPredictorOrdinate[i]) + adblPredictorOrdinate[i + 2] - adblPredictorOrdinate[i + 1])
  408.                         - adblNodeC1[i + 1] * (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i])) /
  409.                             (adblPredictorOrdinate[i + 2] - adblPredictorOrdinate[i]);

  411.                 try {
  412.                     double dblM = 3 * org.drip.numerical.common.NumberUtil.Minimum (new double[]
  413.                         {java.lang.Math.abs (adblNodeC1[i - 1]), java.lang.Math.abs (adblNodeC1[i]),
  414.                             java.lang.Math.abs (dMu0), java.lang.Math.abs (dMuPlus)});

  416.                     if (!org.drip.numerical.common.NumberUtil.SameSign (new double[] {dMu0, dMuMinus,
  417.                             adblNodeC1[i - 1] - adblNodeC1[i - 2], adblNodeC1[i] - adblNodeC1[i - 1]}))
  418.                         dblM = java.lang.Math.max (dblM, 1.5 * java.lang.Math.min (java.lang.Math.abs (dMu0),
  419.                             java.lang.Math.abs (dMuMinus)));
  420.                     else if (!org.drip.numerical.common.NumberUtil.SameSign (new double[] {-dMu0, -dMuPlus,
  421.                             adblNodeC1[i] - adblNodeC1[i - 1], adblNodeC1[i + 1] - adblNodeC1[i]}))
  422.                         dblM = java.lang.Math.max (dblM, 1.5 * java.lang.Math.min (java.lang.Math.abs (dMu0),
  423.                             java.lang.Math.abs (dMuPlus)));

  425.                     adblHyman89C1[i] = 0.;

  427.                     if (adblBesselC1[i] * dMu0 > 0.)
  428.                         adblHyman89C1[i] = adblBesselC1[i] / java.lang.Math.abs (adblBesselC1[i]) *
  429.                             java.lang.Math.min (java.lang.Math.abs (adblBesselC1[i]), dblM);
  430.                 } catch (java.lang.Exception e) {
  431.                     e.printStackTrace();

  433.                     return null;
  434.                 }
  435.             }
  436.         }

  438.         return adblHyman89C1;
  439.     }

  441.     /**
  442.      * Generate a Harmonic C1 Array from the specified Array of Predictor Ordinates and the Response Values
  443.      * 
  444.      *  Fritcsh and Butland (1984) A Method for constructing local monotonic piece-wise cubic interpolants -
  445.      *      SIAM J on Scientific and Statistical Computing 5, 300-304.
  446.      * 
  447.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  448.      * @param adblResponseValue The Response Value Array
  449.      * 
  450.      * @return The C1 Array
  451.      */

  453.     public static final double[] HarmonicC1 (
  454.         final double[] adblPredictorOrdinate,
  455.         final double[] adblResponseValue)
  456.     {
  457.         int iNumResponse = adblResponseValue.length;
  458.         double[] adblHarmonicC1 = new double[iNumResponse];

  460.         double[] adblLinearC1 = LinearC1 (adblPredictorOrdinate, adblResponseValue);

  462.         for (int i = 0; i < iNumResponse; ++i) {
  463.             if (0 == i) {
  464.                 adblHarmonicC1[i] = (adblPredictorOrdinate[2] + adblPredictorOrdinate[1] - 2. *
  465.                     adblPredictorOrdinate[0]) * adblLinearC1[0] / (adblPredictorOrdinate[2] -
  466.                         adblPredictorOrdinate[0]);
  467.                 adblHarmonicC1[i] -= (adblPredictorOrdinate[1] - adblPredictorOrdinate[0]) * adblLinearC1[1]
  468.                     / (adblPredictorOrdinate[2] - adblPredictorOrdinate[0]);
  469.             } else if (iNumResponse - 1 == i) {
  470.                 adblHarmonicC1[i] = -(adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]) *
  471.                     adblLinearC1[i - 2] / (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 2]);
  472.                 adblHarmonicC1[i] += (2. * adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1] -
  473.                     adblPredictorOrdinate[i - 2]) * adblLinearC1[i - 1] / (adblPredictorOrdinate[i] -
  474.                         adblPredictorOrdinate[i - 2]);
  475.             } else {
  476.                 if (adblLinearC1[i - 1] * adblLinearC1[i] <= 0.)
  477.                     adblHarmonicC1[i] = 0.;
  478.                 else {
  479.                     adblHarmonicC1[i] = (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1] + 2. *
  480.                         (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i])) / (3. *
  481.                             (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i])) / adblLinearC1[i - 1];
  482.                     adblHarmonicC1[i] += (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i] + 2. *
  483.                         (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1])) / (3. *
  484.                             (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i])) / adblLinearC1[i];
  485.                     adblHarmonicC1[i] = 1. / adblHarmonicC1[i];
  486.                 }
  487.             }
  488.         }

  490.         return adblHarmonicC1;
  491.     }

  493.     /**
  494.      * Generate a Van Leer Limiter C1 Array from the specified Array of Predictor Ordinates and the Response
  495.      *  Values.
  496.      * 
  497.      *  Van Leer (1974) Towards the Ultimate Conservative Difference Scheme. II - Monotonicity and
  498.      *      Conservation combined in a Second-Order Scheme, Journal of Computational Physics 14 (4), 361-370.
  499.      * 
  500.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  501.      * @param adblResponseValue The Response Value Array
  502.      * 
  503.      * @return The C1 Array
  504.      */

  506.     public static final double[] VanLeerLimiterC1 (
  507.         final double[] adblPredictorOrdinate,
  508.         final double[] adblResponseValue)
  509.     {
  510.         int iNumResponse = adblResponseValue.length;
  511.         double[] dblVanLeerLimiterC1 = new double[iNumResponse];

  513.         double[] adblNodeC1 = LinearC1 (adblPredictorOrdinate, adblResponseValue);

  515.         for (int i = 0; i < iNumResponse; ++i) {
  516.             if (0 == i) {
  517.                 dblVanLeerLimiterC1[i] = (adblPredictorOrdinate[2] + adblPredictorOrdinate[1] - 2. *
  518.                     adblPredictorOrdinate[0]) * adblNodeC1[0] / (adblPredictorOrdinate[2] -
  519.                         adblPredictorOrdinate[0]);
  520.                 dblVanLeerLimiterC1[i] -= (adblPredictorOrdinate[1] - adblPredictorOrdinate[0]) *
  521.                     adblNodeC1[1] / (adblPredictorOrdinate[2] - adblPredictorOrdinate[0]);
  522.             } else if (iNumResponse - 1 == i) {
  523.                 dblVanLeerLimiterC1[i] = -(adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]) *
  524.                     adblNodeC1[i - 2] / (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 2]);
  525.                 dblVanLeerLimiterC1[i] += (2. * adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1] -
  526.                     adblPredictorOrdinate[i - 2]) * adblNodeC1[i - 1] / (adblPredictorOrdinate[i] -
  527.                         adblPredictorOrdinate[i - 2]);
  528.             } else {
  529.                 if (0. != adblNodeC1[i - 1]) {
  530.                     double dblR = adblNodeC1[i] / adblNodeC1[i - 1];

  532.                     double dblRAbsolute = java.lang.Math.abs (dblR);

  534.                     dblVanLeerLimiterC1[i] = adblNodeC1[i] * (dblR + dblRAbsolute) / (1. + dblRAbsolute);
  535.                 } else if (0. >= adblNodeC1[i])
  536.                     dblVanLeerLimiterC1[i] = 0.;
  537.                 else if (0. < adblNodeC1[i])
  538.                     dblVanLeerLimiterC1[i] = 2. * adblNodeC1[i];
  539.             }
  540.         }

  542.         return dblVanLeerLimiterC1;
  543.     }

  545.     /**
  546.      * Generate a Huynh Le Floch Limiter C1 Array from the specified Array of Predictor Ordinates and the
  547.      *  Response Values.
  548.      * 
  549.      *  Huynh (1993) Accurate Monotone Cubic Interpolation, SIAM J on Numerical Analysis 30 (1), 57-100.
  550.      * 
  551.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  552.      * @param adblResponseValue The Response Value Array
  553.      * 
  554.      * @return The C1 Array
  555.      */

  557.     public static final double[] HuynhLeFlochLimiterC1 (
  558.         final double[] adblPredictorOrdinate,
  559.         final double[] adblResponseValue)
  560.     {
  561.         int iNumResponse = adblResponseValue.length;
  562.         double[] adblHuynhLeFlochLimiterC1 = new double[iNumResponse];

  564.         double[] adblNodeC1 = LinearC1 (adblPredictorOrdinate, adblResponseValue);

  566.         for (int i = 0; i < iNumResponse; ++i) {
  567.             if (0 == i) {
  568.                 adblHuynhLeFlochLimiterC1[i] = (adblPredictorOrdinate[2] + adblPredictorOrdinate[1] - 2. *
  569.                     adblPredictorOrdinate[0]) * adblNodeC1[0] / (adblPredictorOrdinate[2] -
  570.                         adblPredictorOrdinate[0]);
  571.                 adblHuynhLeFlochLimiterC1[i] -= (adblPredictorOrdinate[1] - adblPredictorOrdinate[0]) *
  572.                     adblNodeC1[1] / (adblPredictorOrdinate[2] - adblPredictorOrdinate[0]);
  573.             } else if (iNumResponse - 1 == i) {
  574.                 adblHuynhLeFlochLimiterC1[i] = -(adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]) *
  575.                     adblNodeC1[i - 2] / (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 2]);
  576.                 adblHuynhLeFlochLimiterC1[i] += (2. * adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]
  577.                     - adblPredictorOrdinate[i - 2]) * adblNodeC1[i - 1] / (adblPredictorOrdinate[i] -
  578.                         adblPredictorOrdinate[i - 2]);
  579.             } else {
  580.                 double dblMonotoneIndicator = adblNodeC1[i] * adblNodeC1[i - 1];

  582.                 if (0. < dblMonotoneIndicator)
  583.                     adblHuynhLeFlochLimiterC1[i] = 3. * dblMonotoneIndicator * (adblNodeC1[i] +
  584.                         adblNodeC1[i - 1]) / (adblNodeC1[i] * adblNodeC1[i] + adblNodeC1[i - 1] *
  585.                             adblNodeC1[i - 1] * 4. * dblMonotoneIndicator);
  586.                 else
  587.                     adblHuynhLeFlochLimiterC1[i] = 0.;
  588.             }
  589.         }

  591.         return adblHuynhLeFlochLimiterC1;
  592.     }

  594.     /**
  595.      * Generate a Kruger C1 Array from the specified Array of Predictor Ordinates and the Response Values.
  596.      * 
  597.      *  Kruger (2002) Constrained Cubic Spline Interpolations for Chemical Engineering Application,
  598.      *      http://www.korf.co.uk/spline.pdf
  599.      * 
  600.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  601.      * @param adblResponseValue The Response Value Array
  602.      * 
  603.      * @return The C1 Array
  604.      */

  606.     public static final double[] KrugerC1 (
  607.         final double[] adblPredictorOrdinate,
  608.         final double[] adblResponseValue)
  609.     {
  610.         int iNumResponse = adblResponseValue.length;
  611.         double[] adblKrugerSlope = new double[iNumResponse];

  613.         double[] adblSlopeC1 = LinearC1 (adblPredictorOrdinate, adblResponseValue);

  615.         if (null == adblSlopeC1 || adblSlopeC1.length != iNumResponse - 1) return null;

  617.         for (int i = 0; i < iNumResponse; ++i) {
  618.             if (0 != i && iNumResponse - 1 != i) {
  619.                 if (adblSlopeC1[i - 1] * adblSlopeC1[i] <= 0.)
  620.                     adblKrugerSlope[i] = 0.;
  621.                 else
  622.                     adblKrugerSlope[i] = 2. / ((1. / adblSlopeC1[i - 1]) + (1. / adblSlopeC1[i]));
  623.             }
  624.         }

  626.         adblKrugerSlope[0] = 3.5 * adblSlopeC1[0] - 0.5 * adblKrugerSlope[1];
  627.         adblKrugerSlope[iNumResponse - 1] = 3.5 * adblSlopeC1[iNumResponse - 2] - 0.5 *
  628.             adblKrugerSlope[iNumResponse - 2];
  629.         return adblKrugerSlope;
  630.     }

  632.     /**
  633.      * Generate a Akima C1 Array from the specified Array of Predictor Ordinates and the Response Values.
  634.      * 
  635.      *  Akima (1970): A New Method of Interpolation and Smooth Curve Fitting based on Local Procedures,
  636.      *      Journal of the Association for the Computing Machinery 17 (4), 589-602.
  637.      * 
  638.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  639.      * @param adblResponseValue The Response Value Array
  640.      * 
  641.      * @return The C1 Array
  642.      */

  644.     public static final double[] AkimaC1 (
  645.         final double[] adblPredictorOrdinate,
  646.         final double[] adblResponseValue)
  647.     {
  648.         org.drip.spline.pchip.AkimaLocalC1Generator alcr =
  649.             org.drip.spline.pchip.AkimaLocalC1Generator.Create (adblPredictorOrdinate, adblResponseValue);

  651.         return null == alcr ? null : alcr.C1();
  652.     }

  654.     /**
  655.      * Verify if the given Quintic Polynomial is Monotone using the Hyman89 Algorithm
  656.      * 
  657.      *  Doherty, Edelman, and Hyman (1989) Non-negative, monotonic, or convexity preserving cubic and quintic
  658.      *      Hermite interpolation - Mathematics of Computation 52 (186), 471-494.
  659.      * 
  660.      * @param adblPredictorOrdinate Array of Predictor Ordinates
  661.      * @param adblResponseValue Array of Response Values
  662.      * @param adblFirstDerivative Array of First Derivatives
  663.      * @param adblSecondDerivative Array of Second Derivatives
  664.      * 
  665.      * @return TRUE - The given Quintic Polynomial is Monotone
  666.      * 
  667.      * @throws java.lang.Exception Thrown if the Monotonicity cannot be determined
  668.      */

  670.     public static final boolean VerifyHyman89QuinticMonotonicity (
  671.         final double[] adblPredictorOrdinate,
  672.         final double[] adblResponseValue,
  673.         final double[] adblFirstDerivative,
  674.         final double[] adblSecondDerivative)
  675.         throws java.lang.Exception
  676.     {
  677.         if (null == adblPredictorOrdinate || null == adblResponseValue || null == adblFirstDerivative || null
  678.             == adblSecondDerivative)
  679.             throw new java.lang.Exception
  680.                 ("LocalMonotoneCkGenerator::VerifyHyman89QuinticMonotonicity => Invalid Inputs");

  682.         int iNumPredictor = adblPredictorOrdinate.length;

  684.         if (1 >= iNumPredictor || iNumPredictor != adblResponseValue.length || iNumPredictor !=
  685.             adblResponseValue.length || iNumPredictor != adblResponseValue.length)
  686.             throw new java.lang.Exception
  687.                 ("LocalMonotoneCkGenerator::VerifyHyman89QuinticMonotonicity => Invalid Inputs");

  689.         for (int i = 1; i < iNumPredictor - 1; ++i) {
  690.             double dblAbsoluteResponseValue = java.lang.Math.abs (adblResponseValue[i]);

  692.             double dblResponseValueSign = adblResponseValue[i] > 0. ? 1. : -1.;
  693.             double dblHMinus = (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]);
  694.             double dblHPlus = (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i]);

  696.             if (-5. * dblAbsoluteResponseValue / dblHPlus > dblResponseValueSign * adblFirstDerivative[i] ||
  697.                 5. * dblAbsoluteResponseValue / dblHMinus < dblResponseValueSign * adblFirstDerivative[i])
  698.                 return false;

  700.             if (dblResponseValueSign * adblSecondDerivative[i] < dblResponseValueSign * java.lang.Math.max
  701.                 (8. * adblFirstDerivative[i] / dblHMinus - 20. * adblResponseValue[i] / dblHMinus /
  702.                     dblHMinus, -8. * adblFirstDerivative[i] / dblHPlus - 20. * adblResponseValue[i] /
  703.                         dblHPlus / dblHPlus))
  704.                 return false;
  705.         }

  707.         return true;
  708.     }

  710.     /**
  711.      * Generate C1 Slope Quintic Polynomial is Monotone using the Hyman89 Algorithm
  712.      * 
  713.      *  Doherty, Edelman, and Hyman (1989) Non-negative, monotonic, or convexity preserving cubic and quintic
  714.      *      Hermite interpolation - Mathematics of Computation 52 (186), 471-494.
  715.      * 
  716.      * @param adblPredictorOrdinate Array of Predictor Ordinates
  717.      * @param adblResponseValue Array of Response Values
  718.      * @param adblFirstDerivative Array of First Derivatives
  719.      * @param adblSecondDerivative Array of Second Derivatives
  720.      * 
  721.      * @return The C1 Slope Quintic Stretch
  722.      */

  724.     public static final double[] Hyman89QuinticMonotoneC1 (
  725.         final double[] adblPredictorOrdinate,
  726.         final double[] adblResponseValue,
  727.         final double[] adblFirstDerivative,
  728.         final double[] adblSecondDerivative)
  729.     {
  730.         if (null == adblPredictorOrdinate || null == adblResponseValue || null == adblFirstDerivative || null
  731.             == adblSecondDerivative)
  732.             return null;

  734.         int iNumPredictor = adblPredictorOrdinate.length;

  736.         if (1 >= iNumPredictor || iNumPredictor != adblResponseValue.length || iNumPredictor !=
  737.             adblResponseValue.length || iNumPredictor != adblResponseValue.length)
  738.             return null;

  740.         double[] adblAdjFirstDerivative = new double[iNumPredictor];

  742.         double[] adblNodeC1 = LinearC1 (adblPredictorOrdinate, adblResponseValue);

  744.         double[] adblBesselC1 = BesselC1 (adblPredictorOrdinate, adblResponseValue);

  746.         for (int i = 0; i < iNumPredictor; ++i) {
  747.             if (i < 2 || i >= iNumPredictor - 2)
  748.                 adblAdjFirstDerivative[i] = adblBesselC1[i];
  749.             else {
  750.                 double dblSign = 0.;
  751.                 double dblHMinus = (adblPredictorOrdinate[i] - adblPredictorOrdinate[i - 1]);
  752.                 double dblHPlus = (adblPredictorOrdinate[i + 1] - adblPredictorOrdinate[i]);

  754.                 if (adblFirstDerivative[i - 1] * adblFirstDerivative[i] < 0.)
  755.                     dblSign = adblResponseValue[i] > 0. ? 1. : -1.;

  757.                 double dblMinSlope = java.lang.Math.min (java.lang.Math.abs (adblFirstDerivative[i - 1]),
  758.                     java.lang.Math.abs (adblFirstDerivative[i]));

  760.                 if (dblSign >= 0.)
  761.                     adblAdjFirstDerivative[i] = java.lang.Math.min (java.lang.Math.max (0.,
  762.                         adblFirstDerivative[i]), 5. * dblMinSlope);
  763.                 else
  764.                     adblAdjFirstDerivative[i] = java.lang.Math.max (java.lang.Math.min (0.,
  765.                         adblFirstDerivative[i]), -5. * dblMinSlope);

  767.                 double dblA = java.lang.Math.max (0., adblAdjFirstDerivative[i] / adblNodeC1[i - 1]);

  769.                 double dblB = java.lang.Math.max (0., adblAdjFirstDerivative[i + 1] / adblNodeC1[i]);

  771.                 double dblDPlus = adblAdjFirstDerivative[i] * adblNodeC1[i] > 0. ? adblAdjFirstDerivative[i]
  772.                     : 0.;
  773.                 double dblDMinus = adblAdjFirstDerivative[i] * adblNodeC1[i - 1] > 0. ?
  774.                     adblAdjFirstDerivative[i] : 0.;
  775.                 double dblALeft = (-7.9 * dblDPlus - 0.26 * dblDPlus * dblB) / dblHPlus;
  776.                 double dblARight = ((20. - 2. * dblB) * adblNodeC1[i] - 8. * dblDPlus - 0.48 * dblDPlus *
  777.                     dblB) / dblHPlus;
  778.                 double dblBLeft = ((2. * dblA - 20.) * adblNodeC1[i - 1] + 8. * dblDMinus - 0.48 * dblDMinus
  779.                     * dblA) / dblHMinus;
  780.                 double dblBRight = (7.9 * dblDMinus + 0.26 * dblDMinus * dblA) / dblHMinus;

  782.                 if (dblARight <= dblBLeft || dblALeft >= dblBRight) {
  783.                     double dblDenom = ((8. + 0.48 * dblB) / dblHPlus) + ((8. + 0.48 * dblA) / dblHMinus);
  784.                     adblAdjFirstDerivative[i] = (20. - 2. * dblB) * adblNodeC1[i] / dblHPlus;
  785.                     adblAdjFirstDerivative[i] += (20. - 2. * dblA) * adblNodeC1[i - 1] / dblHMinus;
  786.                     adblAdjFirstDerivative[i] /= dblDenom;
  787.                 }
  788.             }
  789.         }

  791.         return adblAdjFirstDerivative;
  792.     }

  794.     /**
  795.      * Generate the Local Control Stretch in accordance with the desired Customization Parameters
  796.      * 
  797.      * @param adblPredictorOrdinate The Predictor Ordinate Array
  798.      * @param adblResponseValue The Response Value Array
  799.      * @param strGeneratorType The C1 Generator Type
  800.      * @param bEliminateSpuriousExtrema TRUE - Eliminate Spurious Extrema
  801.      * @param bApplyMonotoneFilter TRUE - Apply Monotone Filter
  802.      * 
  803.      * @return Instance of the Local Control Stretch
  804.      */

  806.     public static final LocalMonotoneCkGenerator Create (
  807.         final double[] adblPredictorOrdinate,
  808.         final double[] adblResponseValue,
  809.         final java.lang.String strGeneratorType,
  810.         final boolean bEliminateSpuriousExtrema,
  811.         final boolean bApplyMonotoneFilter)
  812.     {
  813.         try {
  814.             LocalMonotoneCkGenerator lcr = new LocalMonotoneCkGenerator (adblPredictorOrdinate,
  815.                 adblResponseValue);

  817.             if (!lcr.generateC1 (strGeneratorType)) return null;

  819.             if (bEliminateSpuriousExtrema && !lcr.eliminateSpuriousExtrema()) return null;

  821.             if (bApplyMonotoneFilter) {
  822.                 if (!lcr.applyMonotoneFilter()) return null;
  823.             }

  825.             return lcr;
  826.         } catch (java.lang.Exception e) {
  827.             e.printStackTrace();
  828.         }

  830.         return null;
  831.     }

  833.     /**
  834.      * Generate the Local Control Stretch in accordance with the desired Customization Parameters
  835.      * 
  836.      * @param aiPredictorOrdinate The Predictor Ordinate Array
  837.      * @param adblResponseValue The Response Value Array
  838.      * @param strGeneratorType The C1 Generator Type
  839.      * @param bEliminateSpuriousExtrema TRUE - Eliminate Spurious Extrema
  840.      * @param bApplyMonotoneFilter TRUE - Apply Monotone Filter
  841.      * 
  842.      * @return Instance of the Local Control Stretch
  843.      */

  845.     public static final LocalMonotoneCkGenerator Create (
  846.         final int[] aiPredictorOrdinate,
  847.         final double[] adblResponseValue,
  848.         final java.lang.String strGeneratorType,
  849.         final boolean bEliminateSpuriousExtrema,
  850.         final boolean bApplyMonotoneFilter)
  851.     {
  852.         if (null == aiPredictorOrdinate) return null;

  854.         int iNumPredictorOrdinate = aiPredictorOrdinate.length;
  855.         double[] adblPredictorOrdinate = new double[iNumPredictorOrdinate];

  857.         if (0 == iNumPredictorOrdinate) return null;

  859.         for (int i = 0; i < iNumPredictorOrdinate; ++i)
  860.             adblPredictorOrdinate[i] = aiPredictorOrdinate[i];

  862.         return Create (adblPredictorOrdinate, adblResponseValue, strGeneratorType, bEliminateSpuriousExtrema,
  863.             bApplyMonotoneFilter);
  864.     }

  866.     private LocalMonotoneCkGenerator (
  867.         final double[] adblPredictorOrdinate,
  868.         final double[] adblResponseValue)
  869.         throws java.lang.Exception
  870.     {
  871.         if (null == (_adblPredictorOrdinate = adblPredictorOrdinate) || null == (_adblResponseValue =
  872.             adblResponseValue))
  873.             throw new java.lang.Exception ("LocalMonotoneCkGenerator ctr: Invalid Inputs!");

  875.         int iSize = _adblPredictorOrdinate.length;

  877.         if (0 == iSize || iSize != _adblResponseValue.length)
  878.             throw new java.lang.Exception ("LocalMonotoneCkGenerator ctr: Invalid Inputs!");
  879.     }

  881.     private boolean generateC1 (
  882.         final java.lang.String strGeneratorType)
  883.     {
  884.         if (null == strGeneratorType || strGeneratorType.isEmpty()) return false;

  886.         if (C1_AKIMA.equalsIgnoreCase (strGeneratorType))
  887.             return null != (_adblC1 = AkimaC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  888.                 _adblC1.length;

  890.         if (C1_BESSEL.equalsIgnoreCase (strGeneratorType))
  891.             return null != (_adblC1 = BesselC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  892.                 _adblC1.length;

  894.         if (C1_HARMONIC.equalsIgnoreCase (strGeneratorType))
  895.             return null != (_adblC1 = HarmonicC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  896.                 _adblC1.length;

  898.         if (C1_HUYNH_LE_FLOCH.equalsIgnoreCase (strGeneratorType))
  899.             return null != (_adblC1 = HuynhLeFlochLimiterC1 (_adblPredictorOrdinate, _adblResponseValue)) &&
  900.                 0 != _adblC1.length;

  902.         if (C1_HYMAN83.equalsIgnoreCase (strGeneratorType))
  903.             return null != (_adblC1 = Hyman83C1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  904.                 _adblC1.length;

  906.         if (C1_HYMAN89.equalsIgnoreCase (strGeneratorType))
  907.             return null != (_adblC1 = Hyman89C1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  908.                 _adblC1.length;

  910.         if (C1_KRUGER.equalsIgnoreCase (strGeneratorType))
  911.             return null != (_adblC1 = KrugerC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  912.                 _adblC1.length;

  914.         if (C1_MONOTONE_CONVEX.equalsIgnoreCase (strGeneratorType))
  915.             return null != (_adblC1 = BesselC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  916.             _adblC1.length;

  918.         if (C1_VANILLA.equalsIgnoreCase (strGeneratorType))
  919.             return null != (_adblC1 = LinearC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  920.                 _adblC1.length;

  922.         if (C1_VAN_LEER.equalsIgnoreCase (strGeneratorType))
  923.             return null != (_adblC1 = VanLeerLimiterC1 (_adblPredictorOrdinate, _adblResponseValue)) && 0 !=
  924.                 _adblC1.length;

  926.         return false;
  927.     }

  929.     private boolean eliminateSpuriousExtrema()
  930.     {
  931.         return null != (_adblC1 = EliminateSpuriousExtrema (_adblC1, LinearC1 (_adblPredictorOrdinate,
  932.             _adblResponseValue))) && 0 != _adblC1.length; 
  933.     }

  935.     private boolean applyMonotoneFilter()
  936.     {
  937.         return null != (_adblC1 = ApplyMonotoneFilter (_adblC1, LinearC1 (_adblPredictorOrdinate,
  938.             _adblResponseValue))) && 0 != _adblC1.length; 
  939.     }

  941.     /**
  942.      * Retrieve the C1 Array
  943.      * 
  944.      * @return The C1 Array
  945.      */

  947.     public double[] C1()
  948.     {
  949.         return _adblC1;
  950.     }
  951. }
Created with JaCoCo 0.7.9.201702052155