LatentStateResponseModel.java

  1. package org.drip.spline.segment;

  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>LatentStateResponseModel</i> implements the single segment basis calibration and inference
  85.  * functionality. It exports the following functionality:
  86.  *
  87.  * <br><br>
  88.  *  <ul>
  89.  *      <li>
  90.  *          Build the LatentStateResponseModel instance from the Basis Function/Shape Controller Set
  91.  *      </li>
  92.  *      <li>
  93.  *          Build the LatentStateResponseModel instance from the Basis Evaluator Set
  94.  *      </li>
  95.  *      <li>
  96.  *          Retrieve the Number of Parameters, Basis Evaluator, Array of the Response Basis Coefficients, and
  97.  *              Segment Design Inelastic Control
  98.  *      </li>
  99.  *      <li>
  100.  *          Calibrate the Segment State from the Calibration Parameter Set
  101.  *      </li>
  102.  *      <li>
  103.  *          Sensitivity Calibrator: Calibrate the Segment Manifest Jacobian from the Calibration Parameter
  104.  *              Set
  105.  *      </li>
  106.  *      <li>
  107.  *          Calibrate the coefficients from the prior Predictor/Response Segment, the Constraint, and fitness
  108.  *              Weights
  109.  *      </li>
  110.  *      <li>
  111.  *          Calibrate the coefficients from the prior Segment and the Response Value at the Right Predictor
  112.  *              Ordinate
  113.  *      </li>
  114.  *      <li>
  115.  *          Calibrate the Coefficients from the Edge Response Values and the Left Edge Response Slope
  116.  *      </li>
  117.  *      <li>
  118.  *          Calibrate the coefficients from the Left Edge Response Value Constraint, the Left Edge Response
  119.  *              Value Slope, and the Right Edge Response Value Constraint
  120.  *      </li>
  121.  *      <li>
  122.  *          Retrieve the Segment Curvature, Length, and the Best Fit DPE
  123.  *      </li>
  124.  *      <li>
  125.  *          Calculate the Response Value and its Derivative at the given Predictor Ordinate
  126.  *      </li>
  127.  *      <li>
  128.  *          Calculate the Ordered Derivative of the Coefficient to the Manifest
  129.  *      </li>
  130.  *      <li>
  131.  *          Calculate the Jacobian of the Segment's Response Basis Function Coefficients to the Edge Inputs
  132.  *      </li>
  133.  *      <li>
  134.  *          Calculate the Jacobian of the Response to the Edge Inputs at the given Predictor Ordinate
  135.  *      </li>
  136.  *      <li>
  137.  *          Calculate the Jacobian of the Response to the Basis Coefficients at the given Predictor Ordinate
  138.  *      </li>
  139.  *      <li>
  140.  *          Calibrate the segment and calculate the Jacobian of the Segment's Response Basis Function
  141.  *              Coefficients to the Edge Parameters
  142.  *      </li>
  143.  *      <li>
  144.  *          Calibrate the Coefficients from the Edge Response Values and the Left Edge Response Value Slope
  145.  *              and calculate the Jacobian of the Segment's Response Basis Function Coefficients to the Edge
  146.  *              Parameters
  147.  *      </li>
  148.  *      <li>
  149.  *          Calibrate the coefficients from the prior Segment and the Response Value at the Right Predictor
  150.  *              Ordinate and calculate the Jacobian of the Segment's Response Basis Function Coefficients to
  151.  *              the Edge Parameters
  152.  *      </li>
  153.  *      <li>
  154.  *          Indicate whether the given segment is monotone. If monotone, may optionally indicate the nature
  155.  *              of the extrema contained inside (maxima/minima/infection)
  156.  *      </li>
  157.  *      <li>
  158.  *          Clip the part of the Segment to the Right of the specified Predictor Ordinate. Retain all other
  159.  *              constraints the same
  160.  *      </li>
  161.  *      <li>
  162.  *          Clip the part of the Segment to the Left of the specified Predictor Ordinate. Retain all other
  163.  *              constraints the same
  164.  *      </li>
  165.  *      <li>
  166.  *          Display the string representation for diagnostic purposes
  167.  *      </li>
  168.  *  </ul>
  169.  *
  170.  * <br><br>
  171.  *  <ul>
  172.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  173.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/SplineBuilderLibrary.md">Spline Builder Library</a></li>
  174.  *      <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>
  175.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spline/segment/README.md">Flexure Penalizing Best Fit Segment</a></li>
  176.  *  </ul>
  177.  * <br><br>
  178.  *
  179.  * @author Lakshmi Krishnamurthy
  180.  */

  182. public class LatentStateResponseModel extends org.drip.spline.segment.LatentStateInelastic {

  184.     /**
  185.      * LEFT NODE VALUE PARAMETER INDEX
  186.      */

  188.     public static final int LEFT_NODE_VALUE_PARAMETER_INDEX = 0;

  190.     /**
  191.      * RIGHT NODE VALUE PARAMETER INDEX
  192.      */

  194.     public static final int RIGHT_NODE_VALUE_PARAMETER_INDEX = 1;

  196.     private double[] _adblResponseBasisCoeff = null;
  197.     private org.drip.spline.segment.BasisEvaluator _be = null;
  198.     private double[][] _aadblDResponseBasisCoeffDConstraint = null;
  199.     private org.drip.spline.params.SegmentInelasticDesignControl _sidc = null;
  200.     private org.drip.numerical.differentiation.WengertJacobian _wjDBasisCoeffDEdgeValue = null;

  202.     private
  203.         org.drip.analytics.support.CaseInsensitiveHashMap<org.drip.spline.segment.LatentStateManifestSensitivity>
  204.             _mapLSMS = new
  205.                 org.drip.analytics.support.CaseInsensitiveHashMap<org.drip.spline.segment.LatentStateManifestSensitivity>();

  207.     /**
  208.      * Build the LatentStateResponseModel instance from the Basis Function/Shape Controller Set
  209.      * 
  210.      * @param dblLeftPredictorOrdinate Left Predictor Ordinate
  211.      * @param dblRightPredictorOrdinate Right Predictor Ordinate
  212.      * @param fs Response Basis Function Set
  213.      * @param rssc Shape Controller
  214.      * @param sidc Segment Inelastic Design Parameters
  215.      * 
  216.      * @return Instance of LatentStateResponseModel
  217.      */

  219.     public static final org.drip.spline.segment.LatentStateResponseModel Create (
  220.         final double dblLeftPredictorOrdinate,
  221.         final double dblRightPredictorOrdinate,
  222.         final org.drip.spline.basis.FunctionSet fs,
  223.         final org.drip.spline.params.ResponseScalingShapeControl rssc,
  224.         final org.drip.spline.params.SegmentInelasticDesignControl sidc)
  225.     {
  226.         try {
  227.             org.drip.spline.segment.SegmentBasisEvaluator sbe = new
  228.                 org.drip.spline.segment.SegmentBasisEvaluator (fs, rssc);

  230.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblLeftPredictorOrdinate) ||
  231.                 !org.drip.numerical.common.NumberUtil.IsValid (dblRightPredictorOrdinate) ||
  232.                 dblLeftPredictorOrdinate == dblRightPredictorOrdinate)
  233.             {
  234.                 return null;
  235.             }

  237.             org.drip.spline.segment.LatentStateResponseModel lsrm = new
  238.                 org.drip.spline.segment.LatentStateResponseModel (dblLeftPredictorOrdinate,
  239.                     dblRightPredictorOrdinate, sbe, sidc);

  241.             return sbe.setContainingInelastics (lsrm) ? lsrm : null;
  242.         } catch (java.lang.Exception e) {
  243.             e.printStackTrace();
  244.         }

  246.         return null;
  247.     }

  249.     /**
  250.      * Build the LatentStateResponseModel instance from the Basis Evaluator Set
  251.      * 
  252.      * @param dblLeftPredictorOrdinate Left Predictor Ordinate
  253.      * @param dblRightPredictorOrdinate Right Predictor Ordinate
  254.      * @param be Basis Evaluator
  255.      * @param sidc Segment Inelastic Design Parameters
  256.      * 
  257.      * @return Instance of LatentStateResponseModel
  258.      */

  260.     public static final org.drip.spline.segment.LatentStateResponseModel Create (
  261.         final double dblLeftPredictorOrdinate,
  262.         final double dblRightPredictorOrdinate,
  263.         final org.drip.spline.segment.BasisEvaluator be,
  264.         final org.drip.spline.params.SegmentInelasticDesignControl sidc)
  265.     {
  266.         try {
  267.             org.drip.spline.segment.LatentStateResponseModel lsrm = new
  268.                 org.drip.spline.segment.LatentStateResponseModel (dblLeftPredictorOrdinate,
  269.                     dblRightPredictorOrdinate, be, sidc);

  271.             return be.setContainingInelastics (lsrm) ? lsrm : null;
  272.         } catch (java.lang.Exception e) {
  273.             e.printStackTrace();
  274.         }

  276.         return null;
  277.     }

  279.     private LatentStateResponseModel (
  280.         final double dblLeftPredictorOrdinate,
  281.         final double dblRightPredictorOrdinate,
  282.         final org.drip.spline.segment.BasisEvaluator be,
  283.         final org.drip.spline.params.SegmentInelasticDesignControl sidc)
  284.         throws java.lang.Exception
  285.     {
  286.         super (dblLeftPredictorOrdinate, dblRightPredictorOrdinate);

  288.         if (null == (_be = be) || null == (_sidc = sidc))
  289.             throw new java.lang.Exception ("LatentStateResponseModel ctr: Invalid Basis Functions!");

  291.         int iNumBasis = _be.numBasis();

  293.         _adblResponseBasisCoeff = new double[iNumBasis];

  295.         if (0 >= iNumBasis || _sidc.Ck() > iNumBasis - 2)
  296.             throw new java.lang.Exception ("LatentStateResponseModel ctr: Invalid inputs!");
  297.     }

  299.     private double[] DResponseDBasisCoeff (
  300.         final double dblPredictorOrdinate,
  301.         final int iOrder)
  302.     {
  303.         if (0 == iOrder) return null;

  305.         int iNumBasis = _be.numBasis();

  307.         double[] adblDResponseDBasisCoeff = new double[iNumBasis];

  309.         for (int i = 0; i < iNumBasis; ++i) {
  310.             try {
  311.                 adblDResponseDBasisCoeff[i] = 1 == iOrder ? _be.shapedBasisFunctionResponse
  312.                     (dblPredictorOrdinate, i) : 0.;
  313.             } catch (java.lang.Exception e) {
  314.                 e.printStackTrace();

  316.                 return null;
  317.             }
  318.         }

  320.         return adblDResponseDBasisCoeff;
  321.     }

  323.     private double[] transmissionCk (
  324.         final double dblPredictorOrdinate,
  325.         final org.drip.spline.segment.LatentStateResponseModel csPreceeding,
  326.         final int iCk)
  327.     {
  328.         double[] adblDeriv = new double[iCk];

  330.         for (int i = 0; i < iCk; ++i) {
  331.             try {
  332.                 adblDeriv[i] = csPreceeding.calcResponseValueDerivative (dblPredictorOrdinate, i + 1);
  333.             } catch (java.lang.Exception e) {
  334.                 e.printStackTrace();

  336.                 return null;
  337.             }
  338.         }

  340.         return adblDeriv;
  341.     }

  343.     private org.drip.spline.segment.LatentStateManifestSensitivity manifestSensitivity (
  344.         final java.lang.String strManifestMeasure)
  345.     {
  346.         return null == strManifestMeasure || strManifestMeasure.isEmpty() || !_mapLSMS.containsKey
  347.             (strManifestMeasure) ? null : _mapLSMS.get (strManifestMeasure);
  348.     }

  350.     private double[] CkDBasisCoeffDPreceedingManifestMeasure (
  351.         final java.lang.String strManifestMeasure)
  352.     {
  353.         org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  354.             (strManifestMeasure);

  356.         if (null == lsms) return null;

  358.         int iCk = lsms.getPMSC().Ck();

  360.         if (0 == iCk) return null;

  362.         double[] adblDBasisCoeffDPreceedingManifestTail = new double[iCk];

  364.         for (int i = 0; i < iCk; ++i)
  365.             adblDBasisCoeffDPreceedingManifestTail[i] = 0.;

  367.         return adblDBasisCoeffDPreceedingManifestTail;
  368.     }

  370.     /**
  371.      * Set the Preceeding Manifest Sensitivity Control Parameters for the specified Manifest Measure
  372.      * 
  373.      * @param strManifestMeasure The Manifest Measure
  374.      * @param pmsc The Preceeding Manifest Sensitivity Control Instance
  375.      * 
  376.      * @return TRUE - Named Preceeding Manifest Sensitivity Control Instance Successfully Set
  377.      */

  379.     public boolean setPreceedingManifestSensitivityControl (
  380.         final java.lang.String strManifestMeasure,
  381.         final org.drip.spline.params.PreceedingManifestSensitivityControl pmsc)
  382.     {
  383.         if (null == strManifestMeasure || strManifestMeasure.isEmpty()) return false;

  385.         try {
  386.             _mapLSMS.put (strManifestMeasure, new org.drip.spline.segment.LatentStateManifestSensitivity
  387.                 (pmsc));

  389.             return true;
  390.         } catch (java.lang.Exception e) {
  391.             e.printStackTrace();
  392.         }

  394.         return false;
  395.     }

  397.     /**
  398.      * Retrieve the Number of Parameters
  399.      * 
  400.      * @return The Number of Parameters
  401.      */

  403.     public int numParameters()
  404.     {
  405.         return _sidc.Ck() + 2;
  406.     }

  408.     /**
  409.      * Retrieve the Basis Evaluator
  410.      * 
  411.      * @return The Basis Evaluator
  412.      */

  414.     public org.drip.spline.segment.BasisEvaluator basisEvaluator()
  415.     {
  416.         return _be;
  417.     }

  419.     /**
  420.      * Retrieve the Array of Response Basis Coefficients
  421.      * 
  422.      * @return The Array of Response Basis Coefficients
  423.      */

  425.     public double[] responseBasisCoefficient()
  426.     {
  427.         return _adblResponseBasisCoeff;
  428.     }

  430.     /**
  431.      * Retrieve the Segment Inelastic Design Control
  432.      * 
  433.      * @return The Segment Inelastic Design Control
  434.      */

  436.     public org.drip.spline.params.SegmentInelasticDesignControl designControl()
  437.     {
  438.         return _sidc;
  439.     }

  441.     /**
  442.      * Main Calibrator: Calibrate the Segment State from the Calibration Parameter Set
  443.      * 
  444.      * @param ssciState The Segment State Calibration Inputs Set
  445.      * 
  446.      * @return TRUE - Calibration Successful
  447.      */

  449.     public boolean calibrateState (
  450.         final org.drip.spline.params.SegmentStateCalibrationInputs ssciState)
  451.     {
  452.         if (null == ssciState) return false;

  454.         double[] adblPredictorOrdinate = ssciState.predictorOrdinates();

  456.         double[] adblResponseValue = ssciState.responseValues();

  458.         double[] adblLeftEdgeDeriv = ssciState.leftEdgeDeriv();

  460.         double[] adblRightEdgeDeriv = ssciState.rightEdgeDeriv();

  462.         org.drip.spline.params.SegmentBestFitResponse sbfr = ssciState.bestFitResponse();

  464.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFC = ssciState.flexureConstraint();

  466.         int iNumConstraint = 0;
  467.         int iNumResponseBasisCoeff = _adblResponseBasisCoeff.length;
  468.         int iNumLeftDeriv = null == adblLeftEdgeDeriv ? 0 : adblLeftEdgeDeriv.length;
  469.         int iNumRightDeriv = null == adblRightEdgeDeriv ? 0 : adblRightEdgeDeriv.length;
  470.         double[] adblPredictorResponseConstraintValue = new double[iNumResponseBasisCoeff];
  471.         int iNumPredictorOrdinate = null == adblPredictorOrdinate ? 0 : adblPredictorOrdinate.length;
  472.         double[][] aadblResponseBasisCoeffConstraint = new
  473.             double[iNumResponseBasisCoeff][iNumResponseBasisCoeff];

  475.         if (null != aSBFC) {
  476.             int iNumPotentialConstraint = aSBFC.length;

  478.             for (int i = 0; i < iNumPotentialConstraint; ++i) {
  479.                 if (null != aSBFC[i]) ++iNumConstraint;
  480.             }
  481.         }

  483.         if (iNumResponseBasisCoeff < iNumPredictorOrdinate + iNumLeftDeriv + iNumRightDeriv + iNumConstraint)
  484.             return false;

  486.         try {
  487.             org.drip.spline.segment.BestFitFlexurePenalizer bffp = new
  488.                 org.drip.spline.segment.BestFitFlexurePenalizer (this, _sidc.curvaturePenaltyControl(),
  489.                     _sidc.lengthPenaltyControl(), sbfr, _be);

  491.             for (int j = 0; j < iNumResponseBasisCoeff; ++j) {
  492.                 if (j < iNumPredictorOrdinate)
  493.                     adblPredictorResponseConstraintValue[j] = adblResponseValue[j];
  494.                 else if (j < iNumPredictorOrdinate + iNumConstraint)
  495.                     adblPredictorResponseConstraintValue[j] = aSBFC[j -
  496.                         iNumPredictorOrdinate].contraintValue();
  497.                 else if (j < iNumPredictorOrdinate + iNumConstraint + iNumLeftDeriv)
  498.                     adblPredictorResponseConstraintValue[j] = adblLeftEdgeDeriv[j - iNumPredictorOrdinate -
  499.                         iNumConstraint];
  500.                 else if (j < iNumPredictorOrdinate + iNumConstraint + iNumLeftDeriv + iNumRightDeriv)
  501.                     adblPredictorResponseConstraintValue[j] = adblRightEdgeDeriv[j - iNumPredictorOrdinate -
  502.                         iNumConstraint - iNumLeftDeriv];
  503.                 else
  504.                     adblPredictorResponseConstraintValue[j] = bffp.basisPairPenaltyConstraint (j);
  505.             }

  507.             for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  508.                 for (int l = 0; l < iNumResponseBasisCoeff; ++l) {
  509.                     double[] adblCalibBasisConstraintWeight = null;

  511.                     if (0 != iNumConstraint && (l >= iNumPredictorOrdinate && l < iNumPredictorOrdinate +
  512.                         iNumConstraint))
  513.                         adblCalibBasisConstraintWeight = aSBFC[l -
  514.                             iNumPredictorOrdinate].responseBasisCoeffWeights();

  516.                     if (l < iNumPredictorOrdinate)
  517.                         aadblResponseBasisCoeffConstraint[l][i] = _be.shapedBasisFunctionResponse
  518.                             (adblPredictorOrdinate[l], i);
  519.                     else if (l < iNumPredictorOrdinate + iNumConstraint)
  520.                         aadblResponseBasisCoeffConstraint[l][i] = adblCalibBasisConstraintWeight[i];
  521.                     else if (l < iNumPredictorOrdinate + iNumConstraint + iNumLeftDeriv)
  522.                         aadblResponseBasisCoeffConstraint[l][i] = _be.shapedBasisFunctionDerivative (left(),
  523.                             l - iNumPredictorOrdinate - iNumConstraint + 1, i);
  524.                     else if (l < iNumPredictorOrdinate + iNumConstraint + iNumLeftDeriv + iNumRightDeriv)
  525.                         aadblResponseBasisCoeffConstraint[l][i] = _be.shapedBasisFunctionDerivative
  526.                             (right(), l - iNumPredictorOrdinate - iNumConstraint - iNumLeftDeriv + 1, i);
  527.                     else
  528.                         aadblResponseBasisCoeffConstraint[l][i] = bffp.basisPairConstraintCoefficient (i, l);
  529.                 }
  530.             }
  531.         } catch (java.lang.Exception e) {
  532.             e.printStackTrace();

  534.             return false;
  535.         }

  537.         org.drip.numerical.linearalgebra.LinearizationOutput lo =
  538.             org.drip.numerical.linearalgebra.LinearSystemSolver.SolveUsingMatrixInversion
  539.                 (aadblResponseBasisCoeffConstraint, adblPredictorResponseConstraintValue);

  541.         if (null == lo) return false;

  543.         double[] adblCalibResponseBasisCoeff = lo.getTransformedRHS();

  545.         if (null == adblCalibResponseBasisCoeff || adblCalibResponseBasisCoeff.length !=
  546.             iNumResponseBasisCoeff || null == (_aadblDResponseBasisCoeffDConstraint =
  547.                 lo.getTransformedMatrix()) || _aadblDResponseBasisCoeffDConstraint.length !=
  548.                     iNumResponseBasisCoeff || _aadblDResponseBasisCoeffDConstraint[0].length !=
  549.                         iNumResponseBasisCoeff)
  550.             return false;

  552.         for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  553.             if (!org.drip.numerical.common.NumberUtil.IsValid (_adblResponseBasisCoeff[i] =
  554.                 adblCalibResponseBasisCoeff[i]))
  555.                 return false;
  556.         }

  558.         return true;
  559.     }

  561.     /**
  562.      * Sensitivity Calibrator: Calibrate the Segment Manifest Measure Jacobian from the Calibration Inputs
  563.      * 
  564.      * @param ssciManifestSensitivity The Segment Manifest Calibration Sensitivity Inputs
  565.      * @param aSBFCState Array of Segment State Basis Flexure Constraints
  566.      * 
  567.      * @return The Manifest Sensitivity Coefficients
  568.      */

  570.     public double[] calibrateManifestJacobian (
  571.         final org.drip.spline.params.SegmentStateCalibrationInputs ssciManifestSensitivity,
  572.         final org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCState)
  573.     {
  574.         if (null == ssciManifestSensitivity) return null;

  576.         double[] adblPredictorOrdinate = ssciManifestSensitivity.predictorOrdinates();

  578.         double[] adblResponseValueManifestSensitivity = ssciManifestSensitivity.responseValues();

  580.         double[] adblLeftEdgeDerivManifestSensitivity = ssciManifestSensitivity.leftEdgeDeriv();

  582.         double[] adblRightEdgeDerivManifestSensitivity = ssciManifestSensitivity.rightEdgeDeriv();

  584.         org.drip.spline.params.SegmentBestFitResponse sbfrManifestSensitivity =
  585.             ssciManifestSensitivity.bestFitResponse();

  587.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCManifestSensitivity =
  588.             ssciManifestSensitivity.flexureConstraint();

  590.         int iNumConstraint = 0;
  591.         int iNumResponseBasisCoeff = _adblResponseBasisCoeff.length;
  592.         int iNumPredictorOrdinate = null == adblPredictorOrdinate ? 0 : adblPredictorOrdinate.length;
  593.         double[] adblPredictorResponseManifestSensitivityConstraint = new double[iNumResponseBasisCoeff];
  594.         int iNumLeftDerivManifestSensitivity = null == adblLeftEdgeDerivManifestSensitivity ? 0 :
  595.             adblLeftEdgeDerivManifestSensitivity.length;
  596.         int iNumRightDerivManifestSensitivity = null == adblRightEdgeDerivManifestSensitivity ? 0 :
  597.             adblRightEdgeDerivManifestSensitivity.length;
  598.         double[][] aadblResponseCoeffConstraintManifestSensitivity = new
  599.             double[iNumResponseBasisCoeff][iNumResponseBasisCoeff];

  601.         if (null != aSBFCState) {
  602.             int iNumPotentialConstraint = aSBFCState.length;

  604.             for (int i = 0; i < iNumPotentialConstraint; ++i) {
  605.                 if (null != aSBFCState[i]) ++iNumConstraint;
  606.             }
  607.         }

  609.         if (iNumResponseBasisCoeff < iNumPredictorOrdinate + iNumLeftDerivManifestSensitivity +
  610.             iNumRightDerivManifestSensitivity + iNumConstraint)
  611.             return null;

  613.         try {
  614.             org.drip.spline.segment.BestFitFlexurePenalizer bffpManifestSensitivity = new
  615.                 org.drip.spline.segment.BestFitFlexurePenalizer (this, null == _sidc ? null :
  616.                     _sidc.curvaturePenaltyControl(), null == _sidc ? null : _sidc.lengthPenaltyControl(),
  617.                         sbfrManifestSensitivity, _be);

  619.             for (int j = 0; j < iNumResponseBasisCoeff; ++j) {
  620.                 if (j < iNumPredictorOrdinate)
  621.                     adblPredictorResponseManifestSensitivityConstraint[j] =
  622.                         adblResponseValueManifestSensitivity[j];
  623.                 else if (j < iNumPredictorOrdinate + iNumConstraint) {
  624.                     adblPredictorResponseManifestSensitivityConstraint[j] = 0.;
  625.                     org.drip.spline.params.SegmentBasisFlexureConstraint sbfcManifestSensitivity =
  626.                         aSBFCManifestSensitivity[j - iNumPredictorOrdinate];

  628.                     if (null != sbfcManifestSensitivity) {
  629.                         adblPredictorResponseManifestSensitivityConstraint[j] =
  630.                             sbfcManifestSensitivity.contraintValue();

  632.                         double[] adblCalibConstraintWeightManifestSensitivity =
  633.                             sbfcManifestSensitivity.responseBasisCoeffWeights();

  635.                         for (int i = 0; i < iNumResponseBasisCoeff; ++i)
  636.                             adblPredictorResponseManifestSensitivityConstraint[j] -=
  637.                                 _adblResponseBasisCoeff[i] * adblCalibConstraintWeightManifestSensitivity[i];
  638.                     }
  639.                 } else if (j < iNumPredictorOrdinate + iNumConstraint + iNumLeftDerivManifestSensitivity)
  640.                     adblPredictorResponseManifestSensitivityConstraint[j] =
  641.                         adblLeftEdgeDerivManifestSensitivity[j - iNumPredictorOrdinate - iNumConstraint];
  642.                 else if (j < iNumPredictorOrdinate + iNumConstraint + iNumLeftDerivManifestSensitivity +
  643.                     iNumRightDerivManifestSensitivity)
  644.                     adblPredictorResponseManifestSensitivityConstraint[j] =
  645.                         adblRightEdgeDerivManifestSensitivity[j - iNumPredictorOrdinate - iNumConstraint -
  646.                             iNumLeftDerivManifestSensitivity];
  647.                 else
  648.                     adblPredictorResponseManifestSensitivityConstraint[j] =
  649.                         bffpManifestSensitivity.basisPairPenaltyConstraint (j);
  650.             }

  652.             for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  653.                 for (int l = 0; l < iNumResponseBasisCoeff; ++l) {
  654.                     double[] adblCalibBasisConstraintWeight = null;

  656.                     if (0 != iNumConstraint && (l >= iNumPredictorOrdinate && l < iNumPredictorOrdinate +
  657.                         iNumConstraint))
  658.                         adblCalibBasisConstraintWeight = aSBFCState[l -
  659.                             iNumPredictorOrdinate].responseBasisCoeffWeights();

  661.                     if (l < iNumPredictorOrdinate)
  662.                         aadblResponseCoeffConstraintManifestSensitivity[l][i] =
  663.                             _be.shapedBasisFunctionResponse (adblPredictorOrdinate[l], i);
  664.                     else if (l < iNumPredictorOrdinate + iNumConstraint)
  665.                         aadblResponseCoeffConstraintManifestSensitivity[l][i] =
  666.                             adblCalibBasisConstraintWeight[i];
  667.                     else if (l < iNumPredictorOrdinate + iNumConstraint + iNumLeftDerivManifestSensitivity)
  668.                         aadblResponseCoeffConstraintManifestSensitivity[l][i] =
  669.                             _be.shapedBasisFunctionDerivative (left(), l - iNumPredictorOrdinate -
  670.                                 iNumConstraint + 1, i);
  671.                     else if (l < iNumPredictorOrdinate + iNumConstraint + iNumLeftDerivManifestSensitivity +
  672.                         iNumRightDerivManifestSensitivity)
  673.                         aadblResponseCoeffConstraintManifestSensitivity[l][i] =
  674.                             _be.shapedBasisFunctionDerivative (right(), l - iNumPredictorOrdinate -
  675.                                 iNumConstraint - iNumLeftDerivManifestSensitivity + 1, i);
  676.                     else
  677.                         aadblResponseCoeffConstraintManifestSensitivity[l][i] =
  678.                             bffpManifestSensitivity.basisPairConstraintCoefficient (i, l);
  679.                 }
  680.             }
  681.         } catch (java.lang.Exception e) {
  682.             e.printStackTrace();

  684.             return null;
  685.         }

  687.         org.drip.numerical.linearalgebra.LinearizationOutput lo =
  688.             org.drip.numerical.linearalgebra.LinearSystemSolver.SolveUsingMatrixInversion
  689.                 (aadblResponseCoeffConstraintManifestSensitivity,
  690.                     adblPredictorResponseManifestSensitivityConstraint);

  692.         return null == lo ? null : lo.getTransformedRHS();
  693.     }

  695.     /**
  696.      * Sensitivity Calibrator: Calibrate the Segment Local Manifest Jacobian from the Calibration Parameter
  697.      *  Set
  698.      * 
  699.      * @param strManifestMeasure Latent State Manifest Measure
  700.      * @param ssciManifestSensitivity The Segment Manifest Calibration Parameter Sensitivity
  701.      * @param aSBFCState Array of Segment State Basis Flexure Constraints
  702.      * 
  703.      * @return TRUE - Local Manifest Sensitivity Calibration Successful
  704.      */

  706.     public boolean calibrateLocalManifestJacobian (
  707.         final java.lang.String strManifestMeasure,
  708.         final org.drip.spline.params.SegmentStateCalibrationInputs ssciManifestSensitivity,
  709.         final org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCState)
  710.     {
  711.         org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  712.             (strManifestMeasure);

  714.         if (null == lsms) return false;

  716.         double[] adblDBasisCoeffDLocalManifest = calibrateManifestJacobian (ssciManifestSensitivity,
  717.             aSBFCState);

  719.         return null == adblDBasisCoeffDLocalManifest || adblDBasisCoeffDLocalManifest.length !=
  720.             _adblResponseBasisCoeff.length ? false : lsms.setDBasisCoeffDLocalManifest
  721.                 (adblDBasisCoeffDLocalManifest);
  722.     }

  724.     /**
  725.      * Sensitivity Calibrator: Calibrate the Segment Preceeding Manifest Jacobian from the Calibration
  726.      *  Parameter Set
  727.      * 
  728.      * @param strManifestMeasure Latent State Manifest
  729.      * @param ssciPreceedingManifestSensitivity The Segment Preceeding Manifest Calibration Parameter
  730.      *  Sensitivity
  731.      * 
  732.      * @return TRUE - Preceeding Manifest Sensitivity Calibration Successful
  733.      */

  735.     public boolean calibratePreceedingManifestJacobian (
  736.         final java.lang.String strManifestMeasure,
  737.         final org.drip.spline.params.SegmentStateCalibrationInputs ssciPreceedingManifestSensitivity)
  738.     {
  739.         org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  740.             (strManifestMeasure);

  742.         if (null == lsms) return false;

  744.         double[] adblDBasisCoeffDPreceedingManifest = calibrateManifestJacobian
  745.             (ssciPreceedingManifestSensitivity, null);

  747.         return null == adblDBasisCoeffDPreceedingManifest || adblDBasisCoeffDPreceedingManifest.length !=
  748.             _adblResponseBasisCoeff.length ? false : lsms.setDBasisCoeffDPreceedingManifest
  749.                 (adblDBasisCoeffDPreceedingManifest);
  750.     }

  752.     /**
  753.      * Calibrate the coefficients from the prior Predictor/Response Segment, the Constraint, and fitness
  754.      *  Weights
  755.      * 
  756.      * @param csPreceeding Preceeding Predictor/Response Segment
  757.      * @param srvcState The Segment State Response Value Constraint
  758.      * @param sbfrState Segment's Best Fit Weighted State Response Values
  759.      * 
  760.      * @return TRUE - If the calibration succeeds
  761.      */

  763.     public boolean calibrate (
  764.         final org.drip.spline.segment.LatentStateResponseModel csPreceeding,
  765.         final org.drip.spline.params.SegmentResponseValueConstraint srvcState,
  766.         final org.drip.spline.params.SegmentBestFitResponse sbfrState)
  767.     {
  768.         int iCk = _sidc.Ck();

  770.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCState = null == srvcState ? null : new
  771.             org.drip.spline.params.SegmentBasisFlexureConstraint[] {srvcState.responseIndexedBasisConstraint
  772.                 (_be, this)};

  774.         double[] adblManifestJacobianDerivAtLeftOrdinate = null;

  776.         if (0 != iCk) {
  777.             adblManifestJacobianDerivAtLeftOrdinate = new double[iCk];

  779.             for (int i = 0; i < iCk; ++i)
  780.                 adblManifestJacobianDerivAtLeftOrdinate[i] = 0.;
  781.         }

  783.         if (null == csPreceeding) {
  784.             try {
  785.                 double[] adblStateDerivAtLeftOrdinate = null;

  787.                 if (0 != iCk) {
  788.                     adblStateDerivAtLeftOrdinate = new double[iCk];

  790.                     for (int i = 0; i < iCk; ++i)
  791.                         adblStateDerivAtLeftOrdinate[i] = _be.responseValueDerivative
  792.                             (_adblResponseBasisCoeff, left(), i);
  793.                 }

  795.                 return calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs (new double[]
  796.                     {left()}, new double[] {_be.responseValue (_adblResponseBasisCoeff, left())},
  797.                         adblStateDerivAtLeftOrdinate, null, aSBFCState, sbfrState));
  798.             } catch (java.lang.Exception e) {
  799.                 e.printStackTrace();
  800.             }

  802.             return false;
  803.         }

  805.         try {
  806.             return calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs (new double[]
  807.                 {left()}, new double[] {csPreceeding.responseValue (left())}, 0 == iCk ? null :
  808.                     transmissionCk (left(), csPreceeding, iCk), null, aSBFCState, sbfrState));
  809.         } catch (java.lang.Exception e) {
  810.             e.printStackTrace();
  811.         }

  813.         return false;
  814.     }

  816.     /**
  817.      * Calibrate the coefficients from the prior Segment and the Response Value at the Right Predictor
  818.      *  Ordinate
  819.      * 
  820.      * @param csPreceeding Preceeding Predictor/Response Segment
  821.      * @param dblRightStateValue Response Value at the Right Predictor Ordinate
  822.      * @param sbfrState Segment's Best Fit Weighted Response Values
  823.      * 
  824.      * @return TRUE - If the calibration succeeds
  825.      */

  827.     public boolean calibrate (
  828.         final LatentStateResponseModel csPreceeding,
  829.         final double dblRightStateValue,
  830.         final org.drip.spline.params.SegmentBestFitResponse sbfrState)
  831.     {
  832.         if (null == csPreceeding) return false;

  834.         int iCk = _sidc.Ck();

  836.         try {
  837.             return calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs (new double[]
  838.                 {left(), right()}, new double[] {csPreceeding.responseValue (left()), dblRightStateValue}, 0
  839.                     != iCk ? csPreceeding.transmissionCk (left(), this, iCk) : null, null, null, sbfrState));
  840.         } catch (java.lang.Exception e) {
  841.             e.printStackTrace();
  842.         }

  844.         return false;
  845.     }

  847.     /**
  848.      * Calibrate the Coefficients from the Edge Response Values and the Left Edge Response Slope
  849.      * 
  850.      * @param dblLeftValue Left Edge Response Value
  851.      * @param dblLeftSlope Left Edge Response Slope
  852.      * @param dblRightValue Right Edge Response Value
  853.      * @param sbfrState Segment's Best Fit Weighted Response Values
  854.      * 
  855.      * @return TRUE - The Calibration Succeeded
  856.      */

  858.     public boolean calibrate (
  859.         final double dblLeftValue,
  860.         final double dblLeftSlope,
  861.         final double dblRightValue,
  862.         final org.drip.spline.params.SegmentBestFitResponse sbfrState)
  863.     {
  864.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblLeftValue) ||
  865.             !org.drip.numerical.common.NumberUtil.IsValid (dblLeftSlope) ||
  866.                 !org.drip.numerical.common.NumberUtil.IsValid (dblRightValue))
  867.             return false;

  869.         try {
  870.             return calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs (new double[]
  871.                 {left(), right()}, new double[] {dblLeftValue, dblRightValue},
  872.                     org.drip.numerical.common.CollectionUtil.DerivArrayFromSlope (numParameters() - 2,
  873.                         dblLeftSlope), null, null, sbfrState));
  874.         } catch (java.lang.Exception e) {
  875.             e.printStackTrace();
  876.         }

  878.         return false;
  879.     }

  881.     /**
  882.      * Calibrate the coefficients from the Left Edge Response Value Constraint, the Left Edge Response Value
  883.      *  Slope, and the Right Edge Response Value Constraint
  884.      * 
  885.      * @param wrvcStateLeft Left Edge Response Value Constraint
  886.      * @param dblLeftSlope Left Edge Response Value Slope
  887.      * @param wrvcStateRight Right Edge Response Value Constraint
  888.      * @param sbfrState Segment's Best Fit Weighted Response
  889.      * 
  890.      * @return TRUE - If the calibration succeeds
  891.      */

  893.     public boolean calibrate (
  894.         final org.drip.spline.params.SegmentResponseValueConstraint wrvcStateLeft,
  895.         final double dblLeftSlope,
  896.         final org.drip.spline.params.SegmentResponseValueConstraint wrvcStateRight,
  897.         final org.drip.spline.params.SegmentBestFitResponse sbfrState)
  898.     {
  899.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCState = null;

  901.         try {
  902.             if (null != wrvcStateLeft || null != wrvcStateRight)
  903.                 aSBFCState = new org.drip.spline.params.SegmentBasisFlexureConstraint[] {null ==
  904.                     wrvcStateLeft ? null : wrvcStateLeft.responseIndexedBasisConstraint (_be, this), null ==
  905.                         wrvcStateRight ? null : wrvcStateRight.responseIndexedBasisConstraint (_be, this)};

  907.             return calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs (null, null,
  908.                 org.drip.numerical.common.CollectionUtil.DerivArrayFromSlope (numParameters() - 2, dblLeftSlope),
  909.                     null, aSBFCState, sbfrState));
  910.         } catch (java.lang.Exception e) {
  911.             e.printStackTrace();
  912.         }

  914.         return false;
  915.     }

  917.     /**
  918.      * Compute the Local and the Preceeding Manifest Measure Sensitivity Coefficients from the Preceeding
  919.      *  Segment, the Local Response Value, the Local Response Value Manifest Measure Sensitivity, and the
  920.      *  Local Best Fit Response Sensitivity
  921.      * 
  922.      * @param csPreceeding Preceeding Predictor/Response Segment
  923.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  924.      * @param srvcState The Segment State Response Value Constraint
  925.      * @param srvcManifestSensitivity The Segment State Response Value Constraint Manifest Sensitivity
  926.      * @param sbfrManifestSensitivity Segment's Best Fit Weighted State Response Value Manifest Sensitivity
  927.      * 
  928.      * @return TRUE - If the calibration succeeds
  929.      */

  931.     public boolean manifestMeasureSensitivity (
  932.         final org.drip.spline.segment.LatentStateResponseModel csPreceeding,
  933.         final java.lang.String strManifestMeasure,
  934.         final org.drip.spline.params.SegmentResponseValueConstraint srvcState,
  935.         final org.drip.spline.params.SegmentResponseValueConstraint srvcManifestSensitivity,
  936.         final org.drip.spline.params.SegmentBestFitResponse sbfrManifestSensitivity)
  937.     {
  938.         if (null == srvcState && null != srvcManifestSensitivity) return false;

  940.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCState = null == srvcState ? null : new
  941.             org.drip.spline.params.SegmentBasisFlexureConstraint[] {srvcState.responseIndexedBasisConstraint
  942.                 (_be, this)};

  944.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCManifestSensitivity = null ==
  945.             srvcManifestSensitivity ? null : new org.drip.spline.params.SegmentBasisFlexureConstraint[]
  946.                 {srvcManifestSensitivity.responseIndexedBasisConstraint (_be, this)};

  948.         double[] adblManifestJacobianDerivAtLeftOrdinate = null;

  950.         int iCk = _sidc.Ck();

  952.         if (0 != iCk) {
  953.             adblManifestJacobianDerivAtLeftOrdinate = new double[iCk];

  955.             for (int i = 0; i < iCk; ++i)
  956.                 adblManifestJacobianDerivAtLeftOrdinate[i] = 0.;
  957.         }

  959.         if (null == csPreceeding) return false;

  961.         try {
  962.             if (null == aSBFCManifestSensitivity) return true;

  964.             if (!calibrateLocalManifestJacobian (strManifestMeasure, new
  965.                 org.drip.spline.params.SegmentStateCalibrationInputs (new double[] {left()}, new double[]
  966.                     {0.}, adblManifestJacobianDerivAtLeftOrdinate, null, aSBFCManifestSensitivity,
  967.                         sbfrManifestSensitivity), aSBFCState))
  968.                 return false;

  970.             org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  971.                 (strManifestMeasure);

  973.             if (null == lsms) return true;

  975.             return lsms.getPMSC().impactFade() ? calibratePreceedingManifestJacobian (strManifestMeasure, new
  976.                 org.drip.spline.params.SegmentStateCalibrationInputs (new double[] {left(), right()}, new
  977.                     double[] {csPreceeding.calcDResponseDManifest (strManifestMeasure, left(), 1), 0.}, null,
  978.                         CkDBasisCoeffDPreceedingManifestMeasure (strManifestMeasure), null, null)) :
  979.                             lsms.setDResponseDPreceedingManifest (csPreceeding.calcDResponseDManifest
  980.                                 (strManifestMeasure, left(), 1));
  981.         } catch (java.lang.Exception e) {
  982.             e.printStackTrace();
  983.         }

  985.         return false;
  986.     }

  988.     /**
  989.      * Compute the Local and the Preceeding Manifest Measure Sensitivity Coefficients from the Preceeding
  990.      *  Segments, the Local Response Value Sensitivity at the Right Predictor Ordinate, and the Local Best
  991.      *  Fit Response Sensitivity
  992.      * 
  993.      * @param csPreceeding Preceeding Predictor/Response Segment
  994.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  995.      * @param dblRightStateManifestSensitivity Response Value Manifest Sensitivity at the Right Predictor
  996.      *  Ordinate
  997.      * @param sbfrManifestSensitivity Segment's Best Fit Weighted Response Value Manifest Sensitivity
  998.      * 
  999.      * @return TRUE - If the calibration succeeds
  1000.      */

  1002.     public boolean manifestMeasureSensitivity (
  1003.         final LatentStateResponseModel csPreceeding,
  1004.         final java.lang.String strManifestMeasure,
  1005.         final double dblRightStateManifestSensitivity,
  1006.         final org.drip.spline.params.SegmentBestFitResponse sbfrManifestSensitivity)
  1007.     {
  1008.         if (null == csPreceeding) return false;

  1010.         int iCk = _sidc.Ck();

  1012.         try {
  1013.             double[] adblManifestJacobianDerivAtLeftOrdinate = null;

  1015.             if (0 != iCk) {
  1016.                 adblManifestJacobianDerivAtLeftOrdinate = new double[iCk];

  1018.                 for (int i = 0; i < iCk; ++i)
  1019.                     adblManifestJacobianDerivAtLeftOrdinate[i] = 0.;
  1020.             }

  1022.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblRightStateManifestSensitivity)) return true;

  1024.             if (!calibrateLocalManifestJacobian (strManifestMeasure, new
  1025.                 org.drip.spline.params.SegmentStateCalibrationInputs (new double[] {left(), right()}, new
  1026.                     double[] {0., dblRightStateManifestSensitivity}, 0 != iCk ?
  1027.                         adblManifestJacobianDerivAtLeftOrdinate : null, null, null, sbfrManifestSensitivity),
  1028.                             null))
  1029.                 return false;

  1031.             org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  1032.                 (strManifestMeasure);

  1034.             if (null == lsms) return true;

  1036.             return lsms.getPMSC().impactFade() ? calibratePreceedingManifestJacobian (strManifestMeasure, new
  1037.                 org.drip.spline.params.SegmentStateCalibrationInputs (new double[] {left(), right()}, new
  1038.                     double[] {csPreceeding.calcDResponseDManifest (strManifestMeasure, left(), 1), 0.}, null,
  1039.                         CkDBasisCoeffDPreceedingManifestMeasure (strManifestMeasure), null, null)) :
  1040.                             lsms.setDResponseDPreceedingManifest (csPreceeding.calcDResponseDManifest
  1041.                                 (strManifestMeasure, left(), 1));
  1042.         } catch (java.lang.Exception e) {
  1043.             e.printStackTrace();
  1044.         }

  1046.         return false;
  1047.     }

  1049.     /**
  1050.      * Compute the Local and the Preceeding Manifest Measure Sensitivity Coefficients from the Local
  1051.      *  Response Value Sensitivity at the Left/Right Predictor Ordinate, the Local Left Response Value
  1052.      *  Sensitivity Slope, and the Local Best Fit Response Sensitivity.
  1053.      * 
  1054.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  1055.      * @param dblLeftManifestSensitivity Left Edge Response Value Manifest Sensitivity
  1056.      * @param dblLeftSlopeManifestSensitivity Left Edge Response Slope Manifest Sensitivity
  1057.      * @param dblRightManifestSensitivity Right Edge Response Value Manifest Sensitivity
  1058.      * @param sbfrManifestSensitivity Segment's Best Fit Weighted Response Values Manifest Sensitivity
  1059.      * 
  1060.      * @return TRUE - The Calibration Succeeded
  1061.      */

  1063.     public boolean manifestMeasureSensitivity (
  1064.         final java.lang.String strManifestMeasure,
  1065.         final double dblLeftManifestSensitivity,
  1066.         final double dblLeftSlopeManifestSensitivity,
  1067.         final double dblRightManifestSensitivity,
  1068.         final org.drip.spline.params.SegmentBestFitResponse sbfrManifestSensitivity)
  1069.     {
  1070.         try {
  1071.             return org.drip.numerical.common.NumberUtil.IsValid (dblLeftManifestSensitivity) &&
  1072.                 org.drip.numerical.common.NumberUtil.IsValid (dblLeftSlopeManifestSensitivity) &&
  1073.                     org.drip.numerical.common.NumberUtil.IsValid (dblRightManifestSensitivity) ?
  1074.                         calibrateLocalManifestJacobian (strManifestMeasure, new
  1075.                             org.drip.spline.params.SegmentStateCalibrationInputs (new double[] {left(),
  1076.                                 right()}, new double[] {dblLeftManifestSensitivity,
  1077.                                     dblRightManifestSensitivity},
  1078.                                         org.drip.numerical.common.CollectionUtil.DerivArrayFromSlope
  1079.                                             (numParameters() - 2, dblLeftSlopeManifestSensitivity), null,
  1080.                                                 null, sbfrManifestSensitivity), null) : true;
  1081.         } catch (java.lang.Exception e) {
  1082.             e.printStackTrace();
  1083.         }

  1085.         return false;
  1086.     }

  1088.     /**
  1089.      * Compute the Local and the Preceeding Manifest Measure Sensitivity Coefficients from the Local
  1090.      *  Response Value/Sensitivity Constraints at the Left/Right Predictor Ordinate, the Local Left
  1091.      *  Response Value Sensitivity Slope, and the Local Best Fit Response Sensitivity
  1092.      * 
  1093.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  1094.      * @param wrvcStateLeft Left Edge Response Value Constraint
  1095.      * @param wrvcStateRight Right Edge Response Value Constraint
  1096.      * @param dblLeftSlopeManifestSensitivity Left Edge Response Value Slope Manifest Sensitivity
  1097.      * @param wrvcStateLeftManifestSensitivity Left Edge Response Value Constraint Manifest Sensitivity
  1098.      * @param wrvcStateRightManifestSensitivity Right Edge Response Value Constraint Manifest Sensitivity
  1099.      * @param sbfrManifestSensitivity Segment's Best Fit Weighted Response Manifest Sensitivity
  1100.      * 
  1101.      * @return TRUE - If the calibration succeeds
  1102.      */

  1104.     public boolean manifestMeasureSensitivity (
  1105.         final java.lang.String strManifestMeasure,
  1106.         final org.drip.spline.params.SegmentResponseValueConstraint wrvcStateLeft,
  1107.         final org.drip.spline.params.SegmentResponseValueConstraint wrvcStateRight,
  1108.         final double dblLeftSlopeManifestSensitivity,
  1109.         final org.drip.spline.params.SegmentResponseValueConstraint wrvcStateLeftManifestSensitivity,
  1110.         final org.drip.spline.params.SegmentResponseValueConstraint wrvcStateRightManifestSensitivity,
  1111.         final org.drip.spline.params.SegmentBestFitResponse sbfrManifestSensitivity)
  1112.     {
  1113.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCState = null;
  1114.         org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFCManifestSensitivity = null;

  1116.         try {
  1117.             if (null != wrvcStateLeft || null != wrvcStateRight)
  1118.                 aSBFCState = new org.drip.spline.params.SegmentBasisFlexureConstraint[] {null ==
  1119.                     wrvcStateLeft ? null : wrvcStateLeft.responseIndexedBasisConstraint (_be, this), null ==
  1120.                         wrvcStateRight ? null : wrvcStateRight.responseIndexedBasisConstraint (_be, this)};

  1122.             if (null != wrvcStateLeftManifestSensitivity || null != wrvcStateRightManifestSensitivity)
  1123.                 aSBFCManifestSensitivity = new org.drip.spline.params.SegmentBasisFlexureConstraint[] {null
  1124.                     == wrvcStateLeftManifestSensitivity ? null :
  1125.                         wrvcStateLeftManifestSensitivity.responseIndexedBasisConstraint (_be, this), null ==
  1126.                             wrvcStateRightManifestSensitivity ? null :
  1127.                                 wrvcStateRightManifestSensitivity.responseIndexedBasisConstraint (_be,
  1128.                                     this)};

  1130.             return null == aSBFCManifestSensitivity ? true : calibrateLocalManifestJacobian
  1131.                 (strManifestMeasure, new org.drip.spline.params.SegmentStateCalibrationInputs (null, null,
  1132.                     org.drip.numerical.common.CollectionUtil.DerivArrayFromSlope (numParameters() - 2,
  1133.                         dblLeftSlopeManifestSensitivity), null, aSBFCManifestSensitivity,
  1134.                             sbfrManifestSensitivity), aSBFCState);
  1135.         } catch (java.lang.Exception e) {
  1136.             e.printStackTrace();
  1137.         }

  1139.         return false;
  1140.     }

  1142.     /**
  1143.      * Retrieve the Segment Curvature DPE
  1144.      * 
  1145.      * @return The Segment Curvature DPE
  1146.      * 
  1147.      * @throws java.lang.Exception Thrown if the Segment Curvature DPE cannot be computed
  1148.      */

  1150.     public double curvatureDPE()
  1151.         throws java.lang.Exception
  1152.     {
  1153.         double dblDPE = 0.;

  1155.         int iNumBasis = _be.numBasis();

  1157.         org.drip.spline.params.SegmentFlexurePenaltyControl sfpc = _sidc.curvaturePenaltyControl();

  1159.         if (null == sfpc) sfpc = new org.drip.spline.params.SegmentFlexurePenaltyControl (2, 1.);

  1161.         org.drip.spline.segment.BestFitFlexurePenalizer bffp = new
  1162.             org.drip.spline.segment.BestFitFlexurePenalizer (this, sfpc, null, null, _be);

  1164.         for (int i = 0; i < iNumBasis; ++i) {
  1165.             for (int j = 0; j < iNumBasis; ++j)
  1166.                 dblDPE += _adblResponseBasisCoeff[i] * _adblResponseBasisCoeff[j] *
  1167.                     bffp.basisPairCurvaturePenalty (i, j);
  1168.         }

  1170.         return sfpc.amplitude() * dblDPE;
  1171.     }

  1173.     /**
  1174.      * Retrieve the Segment Length DPE
  1175.      * 
  1176.      * @return The Segment Length DPE
  1177.      * 
  1178.      * @throws java.lang.Exception Thrown if the Segment Length DPE cannot be computed
  1179.      */

  1181.     public double lengthDPE()
  1182.         throws java.lang.Exception
  1183.     {
  1184.         double dblDPE = 0.;

  1186.         int iNumBasis = _be.numBasis();

  1188.         org.drip.spline.params.SegmentFlexurePenaltyControl sfpcLength = _sidc.lengthPenaltyControl();

  1190.         if (null == sfpcLength) sfpcLength = new org.drip.spline.params.SegmentFlexurePenaltyControl (1, 1.);

  1192.         org.drip.spline.segment.BestFitFlexurePenalizer bffp = new
  1193.             org.drip.spline.segment.BestFitFlexurePenalizer (this, null, sfpcLength, null, _be);

  1195.         for (int i = 0; i < iNumBasis; ++i) {
  1196.             for (int j = 0; j < iNumBasis; ++j)
  1197.                 dblDPE += _adblResponseBasisCoeff[i] * _adblResponseBasisCoeff[j] *
  1198.                     bffp.basisPairLengthPenalty (i, j);
  1199.         }

  1201.         return sfpcLength.amplitude() * dblDPE;
  1202.     }

  1204.     /**
  1205.      * Retrieve the Segment Best Fit DPE
  1206.      * 
  1207.      * @param sbfr The Segment's Best Fit Response Inputs
  1208.      * 
  1209.      * @return The Segment Best Fit DPE
  1210.      * 
  1211.      * @throws java.lang.Exception Thrown if the Segment Best Fit DPE cannot be computed
  1212.      */

  1214.     public double bestFitDPE (
  1215.         final org.drip.spline.params.SegmentBestFitResponse sbfr)
  1216.         throws java.lang.Exception
  1217.     {
  1218.         if (null == sbfr) return 0.;

  1220.         double dblDPE = 0.;

  1222.         int iNumBasis = _be.numBasis();

  1224.         org.drip.spline.segment.BestFitFlexurePenalizer bffp = new
  1225.             org.drip.spline.segment.BestFitFlexurePenalizer (this, null, null, sbfr, _be);

  1227.         for (int i = 0; i < iNumBasis; ++i) {
  1228.             for (int j = 0; j < iNumBasis; ++j)
  1229.                 dblDPE += _adblResponseBasisCoeff[i] * _adblResponseBasisCoeff[j] * bffp.basisBestFitPenalty
  1230.                     (i, j);
  1231.         }

  1233.         return dblDPE;
  1234.     }

  1236.     /**
  1237.      * Calculate the Response Value at the given Predictor Ordinate
  1238.      * 
  1239.      * @param dblPredictorOrdinate Predictor Ordinate
  1240.      * 
  1241.      * @return The Response Value
  1242.      * 
  1243.      * @throws java.lang.Exception Thrown if the calculation did not succeed
  1244.      */

  1246.     public double responseValue (
  1247.         final double dblPredictorOrdinate)
  1248.         throws java.lang.Exception
  1249.     {
  1250.         return _be.responseValue (_adblResponseBasisCoeff, dblPredictorOrdinate);
  1251.     }

  1253.     /**
  1254.      * Calculate the Ordered Response Value Derivative at the Predictor Ordinate
  1255.      * 
  1256.      * @param dblPredictorOrdinate Predictor Ordinate at which the ordered Response Derivative is to be
  1257.      *  calculated
  1258.      * @param iOrder Derivative Order
  1259.      * 
  1260.      * @throws java.lang.Exception Thrown if the Ordered Response Value Derivative cannot be calculated
  1261.      * 
  1262.      * @return Retrieve the Ordered Response Value Derivative
  1263.      */

  1265.     public double calcResponseValueDerivative (
  1266.         final double dblPredictorOrdinate,
  1267.         final int iOrder)
  1268.         throws java.lang.Exception
  1269.     {
  1270.         return 0 == iOrder ? responseValue (dblPredictorOrdinate) : _be.responseValueDerivative
  1271.             (_adblResponseBasisCoeff, dblPredictorOrdinate, iOrder);
  1272.     }

  1274.     /**
  1275.      * Calculate the Ordered Derivative of the Response to the Manifest
  1276.      * 
  1277.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  1278.      * @param dblPredictorOrdinate Predictor Ordinate at which the ordered Derivative of the Response to the
  1279.      *  Manifest is to be calculated
  1280.      * @param iOrder Derivative Order
  1281.      * 
  1282.      * @throws java.lang.Exception Thrown if the Ordered Derivative of the Response to the Manifest cannot be
  1283.      *  calculated
  1284.      * 
  1285.      * @return Retrieve the Ordered Derivative of the Response to the Manifest
  1286.      */

  1288.     public double calcDResponseDManifest (
  1289.         final java.lang.String strManifestMeasure,
  1290.         final double dblPredictorOrdinate,
  1291.         final int iOrder)
  1292.         throws java.lang.Exception
  1293.     {
  1294.         if (0 == iOrder)
  1295.             throw new java.lang.Exception
  1296.                 ("LatentStateResponseModel::calcDResponseDManifest => Invalid Inputs");

  1298.         org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  1299.             (strManifestMeasure);

  1301.         if (null == lsms)
  1302.             throw new java.lang.Exception
  1303.                 ("LatentStateResponseModel::calcDResponseDManifest => Invalid Inputs");

  1305.         return _be.responseValue (lsms.getDBasisCoeffDLocalManifest(), dblPredictorOrdinate);
  1306.     }

  1308.     /**
  1309.      * Calculate the Ordered Derivative of the Response to the Preceeding Manifest
  1310.      * 
  1311.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  1312.      * @param dblPredictorOrdinate Predictor Ordinate at which the ordered Derivative of the Response to the
  1313.      *  Manifest is to be calculated
  1314.      * @param iOrder Derivative Order
  1315.      * 
  1316.      * @throws java.lang.Exception Thrown if the Ordered Derivative of the Response to the Manifest cannot be
  1317.      *  calculated
  1318.      * 
  1319.      * @return Retrieve the Ordered Derivative of the Response to the Preceeding Manifest
  1320.      */

  1322.     public double calcDResponseDPreceedingManifest (
  1323.         final java.lang.String strManifestMeasure,
  1324.         final double dblPredictorOrdinate,
  1325.         final int iOrder)
  1326.         throws java.lang.Exception
  1327.     {
  1328.         if (0 == iOrder)
  1329.             throw new java.lang.Exception
  1330.                 ("LatentStateResponseModel::calcDResponseDPreceedingManifest => Invalid Inputs");

  1332.         org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  1333.             (strManifestMeasure);

  1335.         if (null == lsms)
  1336.             throw new java.lang.Exception
  1337.                 ("LatentStateResponseModel::calcDResponseDPreceedingManifest => Cannot locate state Manifest sensitivity");

  1339.         org.drip.spline.params.PreceedingManifestSensitivityControl pqsc = lsms.getPMSC();

  1341.         double dblDResponseDPreceedingManifest = lsms.getDResponseDPreceedingManifest();

  1343.         if (!pqsc.impactFade())
  1344.             return org.drip.numerical.common.NumberUtil.IsValid (dblDResponseDPreceedingManifest) ?
  1345.                 dblDResponseDPreceedingManifest : 0.;

  1347.         org.drip.spline.segment.BasisEvaluator be = pqsc.basisEvaluator();

  1349.         double[] adblDBasisCoeffDPreceedingManifest = lsms.getDBasisCoeffDPreceedingManifest();

  1351.         return null == adblDBasisCoeffDPreceedingManifest ? 0. : (null == be ? _be : be).responseValue
  1352.             (adblDBasisCoeffDPreceedingManifest, dblPredictorOrdinate);
  1353.     }

  1355.     /**
  1356.      * Retrieve the Manifest Measure Preceeding Manifest Impact Flag
  1357.      * 
  1358.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  1359.      * 
  1360.      * @return The Manifest Measure Preceeding Manifest Impact Flag
  1361.      * 
  1362.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  1363.      */

  1365.     public boolean impactFade (
  1366.         final java.lang.String strManifestMeasure)
  1367.         throws java.lang.Exception
  1368.     {
  1369.         org.drip.spline.segment.LatentStateManifestSensitivity lsms = manifestSensitivity
  1370.             (strManifestMeasure);

  1372.         if (null == lsms)
  1373.             throw new java.lang.Exception
  1374.                 ("LatentStateResponseModel::impactFade => Cannot locate state Manifest sensitivity");

  1376.         return lsms.getPMSC().impactFade();
  1377.     }

  1379.     /**
  1380.      * Calculate the Jacobian of the Segment's Response Basis Function Coefficients to the Edge Inputs
  1381.      * 
  1382.      * @return The Jacobian of the Segment's Response Basis Function Coefficients to the Edge Inputs
  1383.      */

  1385.     public org.drip.numerical.differentiation.WengertJacobian jackDCoeffDEdgeInputs()
  1386.     {
  1387.         if (null != _wjDBasisCoeffDEdgeValue) return _wjDBasisCoeffDEdgeValue;

  1389.         int iNumResponseBasisCoeff = _be.numBasis();

  1391.         try {
  1392.             _wjDBasisCoeffDEdgeValue = new org.drip.numerical.differentiation.WengertJacobian (iNumResponseBasisCoeff,
  1393.                 iNumResponseBasisCoeff);
  1394.         } catch (java.lang.Exception e) {
  1395.             e.printStackTrace();

  1397.             return _wjDBasisCoeffDEdgeValue = null;
  1398.         }

  1400.         for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  1401.             if (!_wjDBasisCoeffDEdgeValue.setWengert (i, _adblResponseBasisCoeff[i]))
  1402.                 return _wjDBasisCoeffDEdgeValue = null;
  1403.         }

  1405.         if (null == _aadblDResponseBasisCoeffDConstraint) return null;

  1407.         int iSize = _aadblDResponseBasisCoeffDConstraint.length;

  1409.         for (int i = 0; i < iSize; ++i) {
  1410.             for (int j = 0; j < iSize; ++j) {
  1411.                 if (!_wjDBasisCoeffDEdgeValue.accumulatePartialFirstDerivative (i, j,
  1412.                     _aadblDResponseBasisCoeffDConstraint[i][j]))
  1413.                     return null;
  1414.             }
  1415.         }

  1417.         return _wjDBasisCoeffDEdgeValue;
  1418.     }

  1420.     /**
  1421.      * Calculate the Jacobian of the Response to the Edge Inputs at the given Predictor Ordinate
  1422.      * 
  1423.      * @param dblPredictorOrdinate The Predictor Ordinate
  1424.      * @param iOrder Order of the Derivative Desired
  1425.      * 
  1426.      * @return The Jacobian of the Response to the Edge Inputs at the given Predictor Ordinate
  1427.      */

  1429.     public org.drip.numerical.differentiation.WengertJacobian jackDResponseDEdgeInput (
  1430.         final double dblPredictorOrdinate,
  1431.         final int iOrder)
  1432.     {
  1433.         try {
  1434.             int iNumResponseBasisCoeff = _be.numBasis();

  1436.             org.drip.numerical.differentiation.WengertJacobian wjDResponseDEdgeParams = null;
  1437.             double[][] aadblDBasisCoeffDEdgeParams = new
  1438.                 double[iNumResponseBasisCoeff][iNumResponseBasisCoeff];

  1440.             double[] adblDResponseDBasisCoeff = DResponseDBasisCoeff (dblPredictorOrdinate, iOrder);

  1442.             if (null == adblDResponseDBasisCoeff || iNumResponseBasisCoeff !=
  1443.                 adblDResponseDBasisCoeff.length)
  1444.                 return null;

  1446.             org.drip.numerical.differentiation.WengertJacobian wjDBasisCoeffDEdgeParams = (null ==
  1447.                 _wjDBasisCoeffDEdgeValue) ? jackDCoeffDEdgeInputs() : _wjDBasisCoeffDEdgeValue;

  1449.             for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  1450.                 for (int j = 0; j < iNumResponseBasisCoeff; ++j)
  1451.                     aadblDBasisCoeffDEdgeParams[j][i] = wjDBasisCoeffDEdgeParams.firstDerivative (j, i);
  1452.             }

  1454.             if (!(wjDResponseDEdgeParams = new org.drip.numerical.differentiation.WengertJacobian (1,
  1455.                 iNumResponseBasisCoeff)).setWengert (0, responseValue (dblPredictorOrdinate)))
  1456.                 return null;

  1458.             for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  1459.                 for (int j = 0; j < iNumResponseBasisCoeff; ++j) {
  1460.                     if (!wjDResponseDEdgeParams.accumulatePartialFirstDerivative (0, i,
  1461.                         adblDResponseDBasisCoeff[j] * aadblDBasisCoeffDEdgeParams[j][i]))
  1462.                         return null;
  1463.                 }
  1464.             }

  1466.             return wjDResponseDEdgeParams;
  1467.         } catch (java.lang.Exception e) {
  1468.             e.printStackTrace();
  1469.         }

  1471.         return null;
  1472.     }

  1474.     /**
  1475.      * Calculate the Jacobian of the Response to the Basis Coefficients at the given Predictor Ordinate
  1476.      * 
  1477.      * @param dblPredictorOrdinate The Predictor Ordinate
  1478.      * @param iOrder Order of the Derivative Desired
  1479.      * 
  1480.      * @return The Jacobian of the Response to the Basis Coefficients at the given Predictor Ordinate
  1481.      */

  1483.     public org.drip.numerical.differentiation.WengertJacobian jackDResponseDBasisCoeff (
  1484.         final double dblPredictorOrdinate,
  1485.         final int iOrder)
  1486.     {
  1487.         try {
  1488.             int iNumResponseBasisCoeff = _be.numBasis();

  1490.             double[] adblBasisDResponseDBasisCoeff = DResponseDBasisCoeff (dblPredictorOrdinate, iOrder);

  1492.             if (null == adblBasisDResponseDBasisCoeff || iNumResponseBasisCoeff !=
  1493.                 adblBasisDResponseDBasisCoeff.length)
  1494.                 return null;

  1496.             org.drip.numerical.differentiation.WengertJacobian wjDResponseDBasisCoeff = new
  1497.                 org.drip.numerical.differentiation.WengertJacobian (1, iNumResponseBasisCoeff);

  1499.             for (int i = 0; i < iNumResponseBasisCoeff; ++i) {
  1500.                 if (!wjDResponseDBasisCoeff.accumulatePartialFirstDerivative (0, i,
  1501.                     adblBasisDResponseDBasisCoeff[i]))
  1502.                     return null;
  1503.             }

  1505.             return wjDResponseDBasisCoeff;
  1506.         } catch (java.lang.Exception e) {
  1507.             e.printStackTrace();
  1508.         }

  1510.         return null;
  1511.     }

  1513.     /**
  1514.      * Calibrate the segment and calculate the Jacobian of the Segment's Response Basis Function Coefficients
  1515.      *  to the Edge Parameters
  1516.      * 
  1517.      * @param adblPredictorOrdinate Array of Predictor Ordinates
  1518.      * @param adblResponseValue Array of Response Values
  1519.      * @param adblLeftEdgeDeriv Array of Left Edge Derivatives
  1520.      * @param adblRightEdgeDeriv Array of Right Edge Derivatives
  1521.      * @param aSBFC Array of Segment Flexure Constraints, expressed as Basis Coefficients
  1522.      * @param sbfr Segment Best Fit Response Instance
  1523.      * 
  1524.      * @return The Jacobian of the Segment's Response Basis Function Coefficients to the Edge Parameters
  1525.      */

  1527.     public org.drip.numerical.differentiation.WengertJacobian jackDCoeffDEdgeParams (
  1528.         final double[] adblPredictorOrdinate,
  1529.         final double[] adblResponseValue,
  1530.         final double[] adblLeftEdgeDeriv,
  1531.         final double[] adblRightEdgeDeriv,
  1532.         final org.drip.spline.params.SegmentBasisFlexureConstraint[] aSBFC,
  1533.         final org.drip.spline.params.SegmentBestFitResponse sbfr)
  1534.     {
  1535.         try {
  1536.             return calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs
  1537.                 (adblPredictorOrdinate, adblResponseValue, adblLeftEdgeDeriv, adblRightEdgeDeriv, aSBFC,
  1538.                     sbfr)) ? jackDCoeffDEdgeInputs() : null;
  1539.         } catch (java.lang.Exception e) {
  1540.             e.printStackTrace();
  1541.         }

  1543.         return null;
  1544.     }

  1546.     /**
  1547.      * Calibrate the Coefficients from the Edge Response Values and the Left Edge Response Value Slope and
  1548.      *  calculate the Jacobian of the Segment's Response Basis Function Coefficients to the Edge Parameters
  1549.      * 
  1550.      * @param dblLeftValue Left Edge Response Value
  1551.      * @param dblLeftSlope Left Edge Response Slope
  1552.      * @param dblRightValue Right Edge Response Value
  1553.      * @param sbfrState Segment's Best Fit Weighted Response Values
  1554.      * 
  1555.      * @return The Jacobian of the Segment's Response Basis Function Coefficients to the Edge Parameters
  1556.      */

  1558.     public org.drip.numerical.differentiation.WengertJacobian jackDCoeffDEdgeParams (
  1559.         final double dblLeftValue,
  1560.         final double dblLeftSlope,
  1561.         final double dblRightValue,
  1562.         final org.drip.spline.params.SegmentBestFitResponse sbfrState)
  1563.     {
  1564.         return calibrate (dblLeftValue, dblLeftSlope, dblRightValue, sbfrState) ? jackDCoeffDEdgeInputs() :
  1565.             null;
  1566.     }

  1568.     /**
  1569.      * Calibrate the coefficients from the prior Segment and the Response Value at the Right Predictor
  1570.      *  Ordinate and calculate the Jacobian of the Segment's Response Basis Function Coefficients to the Edge
  1571.      *  Parameters
  1572.      * 
  1573.      * @param csPreceeding Previous Predictor/Response Segment
  1574.      * @param strManifestMeasure Manifest Measure whose Sensitivity is sought
  1575.      * @param dblRightStateValue Response Value at the Right Predictor Ordinate
  1576.      * @param sbfrState Segment's Best Fit Weighted Response Values
  1577.      * @param dblRightStateManifestSensitivity Response Value Manifest Sensitivity at the Right Predictor
  1578.      *  Ordinate
  1579.      * @param sbfrManifestSensitivity Segment's Best Fit Weighted Response Value Manifest Sensitivity
  1580.      * 
  1581.      * @return The Jacobian
  1582.      */

  1584.     public org.drip.numerical.differentiation.WengertJacobian jackDCoeffDEdgeParams (
  1585.         final LatentStateResponseModel csPreceeding,
  1586.         final java.lang.String strManifestMeasure,
  1587.         final double dblRightStateValue,
  1588.         final org.drip.spline.params.SegmentBestFitResponse sbfrState,
  1589.         final double dblRightStateManifestSensitivity,
  1590.         final org.drip.spline.params.SegmentBestFitResponse sbfrManifestSensitivity)
  1591.     {
  1592.         return !calibrate (csPreceeding, dblRightStateValue, sbfrState) || !manifestMeasureSensitivity
  1593.             (csPreceeding, strManifestMeasure, dblRightStateManifestSensitivity, sbfrManifestSensitivity) ?
  1594.                 null : jackDCoeffDEdgeInputs();
  1595.     }

  1597.     /**
  1598.      * Indicate whether the given segment is monotone. If monotone, may optionally indicate the nature of
  1599.      *  the extrema contained inside (maxima/minima/infection).
  1600.      *  
  1601.      * @return The monotone Type
  1602.      */

  1604.     public org.drip.spline.segment.Monotonocity monotoneType()
  1605.     {
  1606.         if (1 >= _sidc.Ck()) {
  1607.             try {
  1608.                 return new org.drip.spline.segment.Monotonocity
  1609.                     (org.drip.spline.segment.Monotonocity.MONOTONIC);
  1610.             } catch (java.lang.Exception e) {
  1611.                 e.printStackTrace();

  1613.                 return null;
  1614.             }
  1615.         }

  1617.         org.drip.function.definition.R1ToR1 ofDeriv = new
  1618.             org.drip.function.definition.R1ToR1 (null) {
  1619.             @Override public double evaluate (
  1620.                 final double dblX)
  1621.                 throws java.lang.Exception
  1622.             {
  1623.                 return _be.responseValueDerivative (_adblResponseBasisCoeff, dblX, 1);
  1624.             }

  1626.             @Override public org.drip.numerical.differentiation.Differential differential (
  1627.                 final double dblX,
  1628.                 final double dblOFBase,
  1629.                 final int iOrder)
  1630.             {
  1631.                 try {
  1632.                     double dblVariateInfinitesimal = _dc.getVariateInfinitesimal (dblX);

  1634.                     return new org.drip.numerical.differentiation.Differential (dblVariateInfinitesimal,
  1635.                         _be.responseValueDerivative (_adblResponseBasisCoeff, dblX, iOrder) *
  1636.                             dblVariateInfinitesimal);
  1637.                 } catch (java.lang.Exception e) {
  1638.                     e.printStackTrace();
  1639.                 }

  1641.                 return null;
  1642.             }

  1644.             @Override public double integrate (
  1645.                 final double dblBegin,
  1646.                 final double dblEnd)
  1647.                 throws java.lang.Exception
  1648.             {
  1649.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  1650.             }
  1651.         };

  1653.         try {
  1654.             org.drip.function.r1tor1solver.FixedPointFinderOutput fpop = new
  1655.                 org.drip.function.r1tor1solver.FixedPointFinderBrent (0., ofDeriv, false).findRoot
  1656.                     (org.drip.function.r1tor1solver.InitializationHeuristics.FromHardSearchEdges (0., 1.));

  1658.             if (null == fpop || !fpop.containsRoot())
  1659.                 return new org.drip.spline.segment.Monotonocity
  1660.                     (org.drip.spline.segment.Monotonocity.MONOTONIC);

  1662.             double dblExtremum = fpop.getRoot();

  1664.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblExtremum) || dblExtremum <= 0. || dblExtremum
  1665.                 >= 1.)
  1666.                 return new org.drip.spline.segment.Monotonocity
  1667.                     (org.drip.spline.segment.Monotonocity.MONOTONIC);

  1669.             double dbl2ndDeriv = _be.responseValueDerivative (_adblResponseBasisCoeff, dblExtremum, 2);

  1671.             if (0. > dbl2ndDeriv)
  1672.                 return new org.drip.spline.segment.Monotonocity
  1673.                     (org.drip.spline.segment.Monotonocity.MAXIMA);

  1675.             if (0. < dbl2ndDeriv)
  1676.                 return new org.drip.spline.segment.Monotonocity
  1677.                     (org.drip.spline.segment.Monotonocity.MINIMA);

  1679.             if (0. == dbl2ndDeriv)
  1680.                 return new org.drip.spline.segment.Monotonocity
  1681.                     (org.drip.spline.segment.Monotonocity.INFLECTION);

  1683.             return new org.drip.spline.segment.Monotonocity
  1684.                 (org.drip.spline.segment.Monotonocity.NON_MONOTONIC);
  1685.         } catch (java.lang.Exception e) {
  1686.             e.printStackTrace();
  1687.         }

  1689.         try {
  1690.             return new org.drip.spline.segment.Monotonocity (org.drip.spline.segment.Monotonocity.MONOTONIC);
  1691.         } catch (java.lang.Exception e) {
  1692.             e.printStackTrace();
  1693.         }

  1695.         return null;
  1696.     }

  1698.     /**
  1699.      * Clip the part of the Segment to the Right of the specified Predictor Ordinate. Retain all other
  1700.      *  constraints the same.
  1701.      * 
  1702.      * @param dblPredictorOrdinate The Predictor Ordinate
  1703.      * 
  1704.      * @return The Clipped Segment
  1705.      */

  1707.     public LatentStateResponseModel clipLeftOfPredictorOrdinate (
  1708.         final double dblPredictorOrdinate)
  1709.     {
  1710.         try {
  1711.             LatentStateResponseModel csLeftSnipped = LatentStateResponseModel.Create (dblPredictorOrdinate,
  1712.                 right(), _be.replicate(), _sidc);

  1714.             int iCk = _sidc.Ck();

  1716.             double[] adblCalibLeftEdgeDeriv = 0 != iCk ? csLeftSnipped.transmissionCk (dblPredictorOrdinate,
  1717.                 this, iCk) : null;

  1719.             return csLeftSnipped.calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs
  1720.                 (new double[] {dblPredictorOrdinate, right()}, new double[] {responseValue
  1721.                     (dblPredictorOrdinate), responseValue (right())}, adblCalibLeftEdgeDeriv, null, null,
  1722.                         null)) ? csLeftSnipped : null;
  1723.         } catch (java.lang.Exception e) {
  1724.             e.printStackTrace();
  1725.         }

  1727.         return null;
  1728.     }

  1730.     /**
  1731.      * Clip the part of the Segment to the Right of the specified Predictor Ordinate. Retain all other
  1732.      *  constraints the same.
  1733.      * 
  1734.      * @param dblPredictorOrdinate The Predictor Ordinate
  1735.      * 
  1736.      * @return The Clipped Segment
  1737.      */

  1739.     public LatentStateResponseModel clipRightOfPredictorOrdinate (
  1740.         final double dblPredictorOrdinate)
  1741.     {
  1742.         try {
  1743.             LatentStateResponseModel csRightSnipped = LatentStateResponseModel.Create (left(),
  1744.                 dblPredictorOrdinate, _be.replicate(), _sidc);

  1746.             int iCk = _sidc.Ck();

  1748.             return csRightSnipped.calibrateState (new org.drip.spline.params.SegmentStateCalibrationInputs
  1749.                 (new double[] {left(), dblPredictorOrdinate}, new double[] {responseValue (left()),
  1750.                     responseValue (dblPredictorOrdinate)}, 0 != iCk ? csRightSnipped.transmissionCk (left(),
  1751.                         this, iCk) : null, null, null, null)) ? csRightSnipped : null;
  1752.         } catch (java.lang.Exception e) {
  1753.             e.printStackTrace();
  1754.         }

  1756.         return null;
  1757.     }

  1759.     /**
  1760.      * Display the string representation for diagnostic purposes
  1761.      * 
  1762.      * @return The string representation
  1763.      */

  1765.     public java.lang.String displayString()
  1766.     {
  1767.         java.lang.StringBuffer sb = new java.lang.StringBuffer();

  1769.         sb.append ("\t\t\t[" + left() + " => " + right() + "\n");

  1771.         for (int i = 0; i < _adblResponseBasisCoeff.length; ++i) {
  1772.             if (0 != i) sb.append ("  |  ");

  1774.             sb.append (_adblResponseBasisCoeff[i] + "\n");
  1775.         }

  1777.         return sb.toString();
  1778.     }
  1779. }
Created with JaCoCo 0.7.9.201702052155