SegmentResponseValueConstraint.java

  1. package org.drip.spline.params;

  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>SegmentResponseValueConstraint</i> holds the following set of fields that characterize a single global
  85.  * linear constraint between the predictor and the response variables within a single segment, expressed
  86.  * linearly across the constituent nodes. Constraints are expressed as
  87.  * 
  88.  *          C = Sigma_j [W_j * y_j] = V where
  89.  * 
  90.  *  x_j - Predictor j
  91.  *  y_j - Response j
  92.  *  W_j - Weight at ordinate j
  93.  *  V - Value of the Constraint
  94.  * 
  95.  * SegmentResponseValueConstraint exports the following functionality:
  96.  *
  97.  * <br><br>
  98.  *  <ul>
  99.  *      <li>
  100.  *          Retrieve the Array of Predictor Ordinates.
  101.  *      </li>
  102.  *      <li>
  103.  *          Retrieve the Array of Response Weights at each Predictor Ordinate.
  104.  *      </li>
  105.  *      <li>
  106.  *          Retrieve the Constraint Value.
  107.  *      </li>
  108.  *      <li>
  109.  *          Convert the Segment Constraint onto Local Predictor Ordinates, the corresponding Response Basis
  110.  *              Function, and the Shape Controller Realizations.
  111.  *      </li>
  112.  *      <li>
  113.  *          Get the Position of the Predictor Knot relative to the Constraints.
  114.  *      </li>
  115.  *      <li>
  116.  *          Generate a SegmentResponseValueConstraint instance from the given predictor/response pair.
  117.  *      </li>
  118.  *  </ul>
  119.  * 
  120.  * SegmentResponseValueConstraint can be viewed as the global response point value transform of
  121.  *  SegmentBasisFlexureConstraint.
  122.  *
  123.  * <br><br>
  124.  *  <ul>
  125.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  126.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/SplineBuilderLibrary.md">Spline Builder Library</a></li>
  127.  *      <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>
  128.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spline/params/README.md">Spline Segment Construction Control Parameters</a></li>
  129.  *  </ul>
  130.  * <br><br>
  131.  * 
  132.  * @author Lakshmi Krishnamurthy
  133.  */

  135. public class SegmentResponseValueConstraint {

  137.     /**
  138.      * Indicator specifying that the knot is to the left of the constraint ordinates
  139.      */

  141.     public static final int LEFT_OF_CONSTRAINT = 1;

  143.     /**
  144.      * Indicator specifying that the knot is to the right of the constraint ordinates
  145.      */

  147.     public static final int RIGHT_OF_CONSTRAINT = 2;

  149.     /**
  150.      * Indicator specifying that the knot splits the constraint ordinates
  151.      */

  153.     public static final int SPLITS_CONSTRAINT = 4;

  155.     private double[] _adblPredictorOrdinate = null;
  156.     private double[] _adblResponseValueWeight = null;
  157.     private double _dblWeightedResponseValueConstraint = java.lang.Double.NaN;

  159.     /**
  160.      * Generate a SegmentResponseValueConstraint instance from the given predictor/response pair.
  161.      * 
  162.      * @param dblPredictorOrdinate The Predictor Ordinate
  163.      * @param dblResponseValue The Response Value
  164.      * 
  165.      * @return The SegmentResponseValueConstraint instance
  166.      */

  168.     public static final SegmentResponseValueConstraint FromPredictorResponsePair (
  169.         final double dblPredictorOrdinate,
  170.         final double dblResponseValue)
  171.     {
  172.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorOrdinate) ||
  173.             !org.drip.numerical.common.NumberUtil.IsValid (dblResponseValue))
  174.             return null;

  176.         try {
  177.             return new SegmentResponseValueConstraint (new double[] {dblPredictorOrdinate}, new double[]
  178.                 {1.}, dblResponseValue);
  179.         } catch (java.lang.Exception e) {
  180.             e.printStackTrace();
  181.         }

  183.         return null;
  184.     }

  186.     /**
  187.      * SegmentResponseValueConstraint constructor
  188.      * 
  189.      * @param adblPredictorOrdinate The Array of Global Predictor Ordinates
  190.      * @param adblResponseValueWeight The Array of the Weights to be applied to the Response at each
  191.      *  Predictor Ordinate
  192.      * @param dblWeightedResponseValueConstraint The Value of the Weighted Response Value Constraint
  193.      * 
  194.      * @throws java.lang.Exception Throws if the Inputs are Invalid
  195.      */

  197.     public SegmentResponseValueConstraint (
  198.         final double[] adblPredictorOrdinate,
  199.         final double[] adblResponseValueWeight,
  200.         final double dblWeightedResponseValueConstraint)
  201.         throws java.lang.Exception
  202.     {
  203.         if (null == (_adblPredictorOrdinate = adblPredictorOrdinate) || null == (_adblResponseValueWeight =
  204.             adblResponseValueWeight) || !org.drip.numerical.common.NumberUtil.IsValid
  205.                 (_dblWeightedResponseValueConstraint = dblWeightedResponseValueConstraint))
  206.             throw new java.lang.Exception ("SegmentResponseValueConstraint ctr: Invalid Inputs");

  208.         int iNumPredictorOrdinate = adblPredictorOrdinate.length;

  210.         if (0 == iNumPredictorOrdinate || _adblResponseValueWeight.length != iNumPredictorOrdinate)
  211.             throw new java.lang.Exception ("SegmentResponseValueConstraint ctr: Invalid Inputs");
  212.     }

  214.     /**
  215.      * Retrieve the Array of Predictor Ordinates
  216.      * 
  217.      * @return The Array of Predictor Ordinates
  218.      */

  220.     public double[] predictorOrdinates()
  221.     {
  222.         return _adblPredictorOrdinate;
  223.     }

  225.     /**
  226.      * Retrieve the Array of Response Weights at each Predictor Ordinate
  227.      * 
  228.      * @return The Array of Response Weights at each Predictor Ordinate
  229.      */

  231.     public double[] responseWeights()
  232.     {
  233.         return _adblResponseValueWeight;
  234.     }

  236.     /**
  237.      * Retrieve the Constraint Value
  238.      * 
  239.      * @return The Constraint Value
  240.      */

  242.     public double constraintValue()
  243.     {
  244.         return _dblWeightedResponseValueConstraint;
  245.     }

  247.     public void display (
  248.         final java.lang.String strComment)
  249.     {
  250.         for (int i = 0; i < _adblPredictorOrdinate.length; ++i)
  251.             System.out.println ("\t\t" + strComment + " - " + new org.drip.analytics.date.JulianDate ((int)
  252.                 _adblPredictorOrdinate[i]) + " => " + _adblResponseValueWeight[i]);

  254.         System.out.println ("\tConstraint: " + _dblWeightedResponseValueConstraint);
  255.     }

  257.     /**
  258.      * Convert the Segment Constraint onto Local Predictor Ordinates, the corresponding Response Basis
  259.      *  Function, and the Shape Controller Realizations
  260.      * 
  261.      * @param lbe The Local Basis Evaluator
  262.      * @param ics Inelastics transformer to convert coordinate space to Local from Global
  263.      * 
  264.      * @return The Segment Basis Function Constraint
  265.      */

  267.     public org.drip.spline.params.SegmentBasisFlexureConstraint responseIndexedBasisConstraint (
  268.         final org.drip.spline.segment.BasisEvaluator lbe,
  269.         final org.drip.spline.segment.LatentStateInelastic ics)
  270.     {
  271.         if (null == lbe || null == ics) return null;

  273.         int iNumResponseBasis = lbe.numBasis();

  275.         int iNumPredictorOrdinate = _adblPredictorOrdinate.length;
  276.         double[] adblResponseBasisWeight = new double[iNumResponseBasis];

  278.         if (0 == iNumResponseBasis) return null;

  280.         try {
  281.             for (int i = 0; i < iNumResponseBasis; ++i) {
  282.                 adblResponseBasisWeight[i] = 0.;

  284.                 for (int j = 0; j < iNumPredictorOrdinate; ++j)
  285.                     adblResponseBasisWeight[i] += _adblResponseValueWeight[j] *
  286.                         lbe.shapedBasisFunctionResponse (_adblPredictorOrdinate[j], i);
  287.             }

  289.             return new org.drip.spline.params.SegmentBasisFlexureConstraint (adblResponseBasisWeight,
  290.                 _dblWeightedResponseValueConstraint);
  291.         } catch (java.lang.Exception e) {
  292.             e.printStackTrace();
  293.         }

  295.         return null;
  296.     }

  298.     /**
  299.      * Get the Position of the Predictor Knot relative to the Constraints
  300.      * 
  301.      * @param dblPredictorKnot The Predictor Knot Ordinate
  302.      * 
  303.      * @return Indicator specifying whether the Knot is Left of the constraints, Right of the Constraints, or
  304.      *  splits the Constraints
  305.      * 
  306.      * @throws java.lang.Exception Thrown if Inputs are invalid
  307.      */

  309.     public int knotPosition (
  310.         final double dblPredictorKnot)
  311.         throws java.lang.Exception
  312.     {
  313.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPredictorKnot))
  314.             throw new java.lang.Exception ("SegmentResponseValueConstraint::knotPosition => Invalid Inputs");

  316.         if (dblPredictorKnot < _adblPredictorOrdinate[0]) return LEFT_OF_CONSTRAINT;

  318.         if (dblPredictorKnot > _adblPredictorOrdinate[_adblPredictorOrdinate.length - 1])
  319.             return RIGHT_OF_CONSTRAINT;

  321.         return SPLITS_CONSTRAINT;
  322.     }
  323. }
Created with JaCoCo 0.7.9.201702052155