SingleSegmentLagrangePolynomial.java

  1.     
  2. package org.drip.spline.stretch;

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

  8. /*!
  9.  * Copyright (C) 2020 Lakshmi Krishnamurthy
  10.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  11.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  12.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  13.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  14.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  15.  * Copyright (C) 2014 Lakshmi Krishnamurthy
  16.  * Copyright (C) 2013 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>SingleSegmentLagrangePolynomial</i> implements the SingleSegmentSequence Stretch interface using the
  86.  * Lagrange Polynomial Estimator. As such it provides a perfect fit that travels through all the
  87.  * predictor/response pairs causing Runge's instability.
  88.  *
  89.  * <br><br>
  90.  *  <ul>
  91.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  92.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/SplineBuilderLibrary.md">Spline Builder Library</a></li>
  93.  *      <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>
  94.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spline/stretch/README.md">Multi-Segment Sequence Spline Stretch</a></li>
  95.  *  </ul>
  96.  * <br><br>
  97.  *
  98.  * @author Lakshmi Krishnamurthy
  99.  */

  101. public class SingleSegmentLagrangePolynomial implements org.drip.spline.stretch.SingleSegmentSequence {
  102.     private static final double DIFF_SCALE = 1.0e-06;
  103.     private static final int MAXIMA_PREDICTOR_ORDINATE_NODE = 1;
  104.     private static final int MINIMA_PREDICTOR_ORDINATE_NODE = 2;
  105.     private static final int MONOTONE_PREDICTOR_ORDINATE_NODE = 4;

  107.     private double[] _adblResponseValue = null;
  108.     private double[] _adblPredictorOrdinate = null;

  110.     private static final double CalcAbsoluteMin (
  111.         final double[] adblY)
  112.         throws java.lang.Exception
  113.     {
  114.         if (null == adblY)
  115.             throw new java.lang.Exception
  116.                 ("SingleSegmentLagrangePolynomial::CalcAbsoluteMin => Invalid Inputs");

  118.         int iNumPoints = adblY.length;

  120.         if (1 >= iNumPoints)
  121.             throw new java.lang.Exception
  122.                 ("SingleSegmentLagrangePolynomial::CalcAbsoluteMin => Invalid Inputs");

  124.         double dblMin = java.lang.Math.abs (adblY[0]);

  126.         for (int i = 0; i < iNumPoints; ++i) {
  127.             double dblValue = java.lang.Math.abs (adblY[i]);

  129.             dblMin = dblMin > dblValue ? dblValue : dblMin;
  130.         }

  132.         return dblMin;
  133.     }

  135.     private static final double CalcMinDifference (
  136.         final double[] adblY)
  137.         throws java.lang.Exception
  138.     {
  139.         if (null == adblY)
  140.             throw new java.lang.Exception
  141.                 ("SingleSegmentLagrangePolynomial::CalcMinDifference => Invalid Inputs");

  143.         int iNumPoints = adblY.length;

  145.         if (1 >= iNumPoints)
  146.             throw new java.lang.Exception
  147.                 ("SingleSegmentLagrangePolynomial::CalcMinDifference => Invalid Inputs");

  149.         double dblMinDiff = java.lang.Math.abs (adblY[0] - adblY[1]);

  151.         for (int i = 0; i < iNumPoints; ++i) {
  152.             for (int j = i + 1; j < iNumPoints; ++j) {
  153.                 double dblDiff = java.lang.Math.abs (adblY[i] - adblY[j]);

  155.                 dblMinDiff = dblMinDiff > dblDiff ? dblDiff : dblMinDiff;
  156.             }
  157.         }

  159.         return dblMinDiff;
  160.     }

  162.     private static final double EstimateBumpDelta (
  163.         final double[] adblY)
  164.         throws java.lang.Exception
  165.     {
  166.         double dblBumpDelta = CalcMinDifference (adblY);

  168.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblBumpDelta) || 0. == dblBumpDelta)
  169.             dblBumpDelta = CalcAbsoluteMin (adblY);

  171.         return 0. == dblBumpDelta ? DIFF_SCALE : dblBumpDelta * DIFF_SCALE;
  172.     }

  174.     /**
  175.      * SingleSegmentLagrangePolynomial constructor
  176.      * 
  177.      * @param adblPredictorOrdinate Array of Predictor Ordinates
  178.      * 
  179.      * @throws java.lang.Exception Thrown if inputs are invalid
  180.      */

  182.     public SingleSegmentLagrangePolynomial (
  183.         final double[] adblPredictorOrdinate)
  184.         throws java.lang.Exception
  185.     {
  186.         if (null == (_adblPredictorOrdinate = adblPredictorOrdinate))
  187.             throw new java.lang.Exception ("SingleSegmentLagrangePolynomial ctr: Invalid Inputs");

  189.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;

  191.         if (1 >= iNumPredictorOrdinate)
  192.             throw new java.lang.Exception ("SingleSegmentLagrangePolynomial ctr: Invalid Inputs");

  194.         for (int i = 0; i < iNumPredictorOrdinate; ++i) {
  195.             for (int j = i + 1; j < iNumPredictorOrdinate; ++j) {
  196.                 if (_adblPredictorOrdinate[i] == _adblPredictorOrdinate[j])
  197.                     throw new java.lang.Exception ("SingleSegmentLagrangePolynomial ctr: Invalid Inputs");
  198.             }
  199.         }
  200.     }

  202.     @Override public boolean setup (
  203.         final double dblYLeading,
  204.         final double[] adblResponseValue,
  205.         final org.drip.spline.params.StretchBestFitResponse rbfr,
  206.         final org.drip.spline.stretch.BoundarySettings bs,
  207.         final int iCalibrationDetail)
  208.     {
  209.         return null != (_adblResponseValue = adblResponseValue) && _adblResponseValue.length ==
  210.             _adblPredictorOrdinate.length;
  211.     }

  213.     @Override public double responseValue (
  214.         final double dblPredictorOrdinate)
  215.         throws java.lang.Exception
  216.     {
  217.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate))
  218.             throw new java.lang.Exception
  219.                 ("SingleSegmentLagrangePolynomial::responseValue => Invalid inputs!");

  221.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;

  223.         if (_adblPredictorOrdinate[0] > dblPredictorOrdinate ||
  224.             _adblPredictorOrdinate[iNumPredictorOrdinate - 1] < dblPredictorOrdinate)
  225.             throw new java.lang.Exception
  226.                 ("SingleSegmentLagrangePolynomial::responseValue => Input out of range!");

  228.         double dblResponse = 0;

  230.         for (int i = 0; i < iNumPredictorOrdinate; ++i) {
  231.             double dblResponsePredictorOrdinateContribution = _adblResponseValue[i];

  233.             for (int j = 0; j < iNumPredictorOrdinate; ++j) {
  234.                 if (i != j)
  235.                     dblResponsePredictorOrdinateContribution = dblResponsePredictorOrdinateContribution *
  236.                         (dblPredictorOrdinate - _adblPredictorOrdinate[j]) / (_adblPredictorOrdinate[i] -
  237.                             _adblPredictorOrdinate[j]);
  238.             }

  240.             dblResponse += dblResponsePredictorOrdinateContribution;
  241.         }

  243.         return dblResponse;
  244.     }

  246.     @Override public double responseValueDerivative (
  247.         final double dblPredictorOrdinate,
  248.         final int iOrder)
  249.         throws java.lang.Exception
  250.     {
  251.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate) || 0 >= iOrder)
  252.             throw new java.lang.Exception
  253.                 ("SingleSegmentLagrangePolynomial::responseValueDerivative => Invalid inputs!");

  255.         org.drip.function.definition.R1ToR1 au = new org.drip.function.definition.R1ToR1
  256.             (null) {
  257.             @Override public double evaluate (
  258.                 double dblX)
  259.                 throws java.lang.Exception
  260.             {
  261.                 return responseValue (dblX);
  262.             }
  263.         };

  265.         return au.derivative (dblPredictorOrdinate, iOrder);
  266.     }

  268.     @Override public org.drip.numerical.differentiation.WengertJacobian jackDResponseDCalibrationInput (
  269.         final double dblPredictorOrdinate,
  270.         final int iOrder)
  271.     {
  272.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate)) return null;

  274.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;
  275.         double dblInputResponseSensitivityShift = java.lang.Double.NaN;
  276.         double dblResponseWithUnadjustedResponseInput = java.lang.Double.NaN;
  277.         org.drip.numerical.differentiation.WengertJacobian wjDResponseDResponseInput = null;

  279.         if (_adblPredictorOrdinate[0] > dblPredictorOrdinate ||
  280.             _adblPredictorOrdinate[iNumPredictorOrdinate - 1] < dblPredictorOrdinate)
  281.             return null;

  283.         try {
  284.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblInputResponseSensitivityShift =
  285.                 EstimateBumpDelta (_adblResponseValue)) || !org.drip.numerical.common.NumberUtil.IsValid
  286.                     (dblResponseWithUnadjustedResponseInput = responseValue (dblPredictorOrdinate)))
  287.                 return null;

  289.             wjDResponseDResponseInput = new org.drip.numerical.differentiation.WengertJacobian (1,
  290.                 iNumPredictorOrdinate);
  291.         } catch (java.lang.Exception e) {
  292.             e.printStackTrace();

  294.             return null;
  295.         }

  297.         for (int i = 0; i < iNumPredictorOrdinate; ++i) {
  298.             double[] adblSensitivityShiftedInputResponse = new double[iNumPredictorOrdinate];

  300.             for (int j = 0; j < iNumPredictorOrdinate; ++j)
  301.                 adblSensitivityShiftedInputResponse[j] = i == j ? _adblResponseValue[j] +
  302.                     dblInputResponseSensitivityShift : _adblResponseValue[j];

  304.             try {
  305.                 SingleSegmentLagrangePolynomial lps = new SingleSegmentLagrangePolynomial
  306.                     (_adblPredictorOrdinate);

  308.                 if (!lps.setup (adblSensitivityShiftedInputResponse[0], adblSensitivityShiftedInputResponse,
  309.                     null, org.drip.spline.stretch.BoundarySettings.FloatingStandard(),
  310.                         org.drip.spline.stretch.MultiSegmentSequence.CALIBRATE) ||
  311.                             !wjDResponseDResponseInput.accumulatePartialFirstDerivative (0, i,
  312.                                 (lps.responseValue (dblPredictorOrdinate) -
  313.                                     dblResponseWithUnadjustedResponseInput) /
  314.                                         dblInputResponseSensitivityShift))
  315.                     return null;
  316.             } catch (java.lang.Exception e) {
  317.                 e.printStackTrace();

  319.                 return null;
  320.             }
  321.         }

  323.         return wjDResponseDResponseInput;
  324.     }

  326.     @Override public org.drip.numerical.differentiation.WengertJacobian jackDResponseDManifestMeasure (
  327.         final java.lang.String strManifestMeasure,
  328.         final double dblPredictorOrdinate,
  329.         final int iOrder)
  330.     {
  331.         return null;
  332.     }

  334.     @Override public org.drip.spline.segment.Monotonocity monotoneType (
  335.         final double dblPredictorOrdinate)
  336.     {
  337.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate)) return null;

  339.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;

  341.         if (_adblPredictorOrdinate[0] > dblPredictorOrdinate ||
  342.             _adblPredictorOrdinate[iNumPredictorOrdinate - 1] < dblPredictorOrdinate)
  343.             return null;

  345.         if (2 == iNumPredictorOrdinate) {
  346.             try {
  347.                 return new org.drip.spline.segment.Monotonocity
  348.                     (org.drip.spline.segment.Monotonocity.MONOTONIC);
  349.             } catch (java.lang.Exception e) {
  350.                 e.printStackTrace();

  352.                 return null;
  353.             }
  354.         }

  356.         org.drip.function.definition.R1ToR1 auDeriv = new
  357.             org.drip.function.definition.R1ToR1 (null) {
  358.             @Override public double evaluate (
  359.                 final double dblX)
  360.                 throws java.lang.Exception
  361.             {
  362.                 double dblDeltaX = CalcMinDifference (_adblPredictorOrdinate) * DIFF_SCALE;

  364.                 return (responseValue (dblX + dblDeltaX) - responseValue (dblX)) / dblDeltaX;
  365.             }

  367.             @Override public double integrate (
  368.                 final double dblBegin,
  369.                 final double dblEnd)
  370.                 throws java.lang.Exception
  371.             {
  372.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  373.             }
  374.         };

  376.         try {
  377.             org.drip.function.r1tor1solver.FixedPointFinderOutput fpop = new
  378.                 org.drip.function.r1tor1solver.FixedPointFinderBrent (0., auDeriv, true).findRoot
  379.                     (org.drip.function.r1tor1solver.InitializationHeuristics.FromHardSearchEdges (0., 1.));

  381.             if (null == fpop || !fpop.containsRoot())
  382.                 return new org.drip.spline.segment.Monotonocity
  383.                     (org.drip.spline.segment.Monotonocity.MONOTONIC);

  385.             double dblExtremum = fpop.getRoot();

  387.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblExtremum) || dblExtremum <= 0. || dblExtremum
  388.                 >= 1.)
  389.                 return new org.drip.spline.segment.Monotonocity
  390.                     (org.drip.spline.segment.Monotonocity.MONOTONIC);

  392.             double dblDeltaX = CalcMinDifference (_adblPredictorOrdinate) * DIFF_SCALE;

  394.             double dbl2ndDeriv = responseValue (dblExtremum + dblDeltaX) + responseValue (dblExtremum -
  395.                 dblDeltaX) - 2. * responseValue (dblPredictorOrdinate);

  397.             if (0. > dbl2ndDeriv)
  398.                 return new org.drip.spline.segment.Monotonocity
  399.                     (org.drip.spline.segment.Monotonocity.MAXIMA);

  401.             if (0. < dbl2ndDeriv)
  402.                 return new org.drip.spline.segment.Monotonocity
  403.                     (org.drip.spline.segment.Monotonocity.MINIMA);

  405.             if (0. == dbl2ndDeriv)
  406.                 return new org.drip.spline.segment.Monotonocity
  407.                     (org.drip.spline.segment.Monotonocity.INFLECTION);

  409.             return new org.drip.spline.segment.Monotonocity
  410.                 (org.drip.spline.segment.Monotonocity.NON_MONOTONIC);
  411.         } catch (java.lang.Exception e) {
  412.             e.printStackTrace();
  413.         }

  415.         try {
  416.             return new org.drip.spline.segment.Monotonocity
  417.                 (org.drip.spline.segment.Monotonocity.MONOTONIC);
  418.         } catch (java.lang.Exception e) {
  419.             e.printStackTrace();
  420.         }

  422.         return null;
  423.     }

  425.     @Override public boolean isLocallyMonotone()
  426.         throws java.lang.Exception
  427.     {
  428.         org.drip.spline.segment.Monotonocity sm = monotoneType (0.5 * (_adblPredictorOrdinate[0] +
  429.             _adblPredictorOrdinate[_adblPredictorOrdinate.length - 1]));

  431.         return null != sm && org.drip.spline.segment.Monotonocity.MONOTONIC == sm.type();
  432.     }

  434.     @Override public boolean isCoMonotone (
  435.         final double[] adblMeasuredResponse)
  436.         throws java.lang.Exception
  437.     {
  438.         if (null == adblMeasuredResponse) return false;

  440.         int iNumMeasuredResponse = adblMeasuredResponse.length;

  442.         if (2 >= iNumMeasuredResponse) return false;

  444.         int[] aiNodeMiniMax = new int[iNumMeasuredResponse];
  445.         int[] aiMonotoneType = new int[iNumMeasuredResponse];

  447.         for (int i = 0; i < iNumMeasuredResponse; ++i) {
  448.             if (0 == i || iNumMeasuredResponse - 1 == i)
  449.                 aiNodeMiniMax[i] = 0;
  450.             else {
  451.                 if (adblMeasuredResponse[i - 1] < adblMeasuredResponse[i] && adblMeasuredResponse[i + 1] <
  452.                     adblMeasuredResponse[i])
  453.                     aiNodeMiniMax[i] = MAXIMA_PREDICTOR_ORDINATE_NODE;
  454.                 else if (adblMeasuredResponse[i - 1] > adblMeasuredResponse[i] && adblMeasuredResponse[i + 1]
  455.                     > adblMeasuredResponse[i])
  456.                     aiNodeMiniMax[i] = MINIMA_PREDICTOR_ORDINATE_NODE;
  457.                 else
  458.                     aiNodeMiniMax[i] = MONOTONE_PREDICTOR_ORDINATE_NODE;
  459.             }

  461.             org.drip.spline.segment.Monotonocity sm = monotoneType (adblMeasuredResponse[i]);

  463.             aiMonotoneType[i] = null != sm ? sm.type() :
  464.                 org.drip.spline.segment.Monotonocity.NON_MONOTONIC;
  465.         }

  467.         for (int i = 1; i < iNumMeasuredResponse - 1; ++i) {
  468.             if (MAXIMA_PREDICTOR_ORDINATE_NODE == aiNodeMiniMax[i]) {
  469.                 if (org.drip.spline.segment.Monotonocity.MAXIMA != aiMonotoneType[i] &&
  470.                     org.drip.spline.segment.Monotonocity.MAXIMA != aiMonotoneType[i - 1])
  471.                     return false;
  472.             } else if (MINIMA_PREDICTOR_ORDINATE_NODE == aiNodeMiniMax[i]) {
  473.                 if (org.drip.spline.segment.Monotonocity.MINIMA != aiMonotoneType[i] &&
  474.                     org.drip.spline.segment.Monotonocity.MINIMA != aiMonotoneType[i - 1])
  475.                     return false;
  476.             }
  477.         }

  479.         return true;
  480.     }

  482.     @Override public boolean isKnot (
  483.         final double dblPredictorOrdinate)
  484.     {
  485.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate)) return false;

  487.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;

  489.         if (_adblPredictorOrdinate[0] > dblPredictorOrdinate ||
  490.             _adblPredictorOrdinate[iNumPredictorOrdinate - 1] < dblPredictorOrdinate)
  491.             return false;

  493.         for (int i = 0; i < iNumPredictorOrdinate; ++i) {
  494.             if (dblPredictorOrdinate == _adblPredictorOrdinate[i]) return true;
  495.         }

  497.         return false;
  498.     }

  500.     @Override public boolean resetNode (
  501.         final int iPredictorOrdinateNodeIndex,
  502.         final double dblResetResponse)
  503.     {
  504.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblResetResponse)) return false;

  506.         if (iPredictorOrdinateNodeIndex > _adblPredictorOrdinate.length) return false;

  508.         _adblResponseValue[iPredictorOrdinateNodeIndex] = dblResetResponse;
  509.         return true;
  510.     }

  512.     @Override public boolean resetNode (
  513.         final int iPredictorOrdinateNodeIndex,
  514.         final org.drip.spline.params.SegmentResponseValueConstraint sprcReset)
  515.     {
  516.         return false;
  517.     }

  519.     @Override public org.drip.function.definition.R1ToR1 toAU()
  520.     {
  521.         org.drip.function.definition.R1ToR1 au = new
  522.             org.drip.function.definition.R1ToR1 (null)
  523.         {
  524.             @Override public double evaluate (
  525.                 final double dblVariate)
  526.                 throws java.lang.Exception
  527.             {
  528.                 return responseValue (dblVariate);
  529.             }

  531.             @Override public double derivative (
  532.                 final double dblVariate,
  533.                 final int iOrder)
  534.                 throws java.lang.Exception
  535.             {
  536.                 return responseValueDerivative (dblVariate, iOrder);
  537.             }
  538.         };

  540.         return au;
  541.     }

  543.     @Override public double getLeftPredictorOrdinateEdge()
  544.     {
  545.         return _adblPredictorOrdinate[0];
  546.     }

  548.     @Override public double getRightPredictorOrdinateEdge()
  549.     {
  550.         return _adblPredictorOrdinate[_adblPredictorOrdinate.length - 1];
  551.     }
  552. }
Created with JaCoCo 0.7.9.201702052155