PolynomialBasisSpline.java

  1. package org.drip.sample.spline;

  3. import org.drip.function.r1tor1.*;
  4. import org.drip.numerical.differentiation.WengertJacobian;
  5. import org.drip.spline.basis.*;
  6. import org.drip.spline.params.*;
  7. import org.drip.spline.segment.*;

  9. /*
  10.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  11.  */

  13. /*!
  14.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  15.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  16.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  17.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  18.  * Copyright (C) 2014 Lakshmi Krishnamurthy
  19.  * Copyright (C) 2013 Lakshmi Krishnamurthy
  20.  * 
  21.  *  This file is part of DRIP, a free-software/open-source library for buy/side financial/trading model
  22.  *      libraries targeting analysts and developers
  23.  *      https://lakshmidrip.github.io/DRIP/
  24.  *  
  25.  *  DRIP is composed of four main libraries:
  26.  *  
  27.  *  - DRIP Fixed Income - https://lakshmidrip.github.io/DRIP-Fixed-Income/
  28.  *  - DRIP Asset Allocation - https://lakshmidrip.github.io/DRIP-Asset-Allocation/
  29.  *  - DRIP Numerical Optimizer - https://lakshmidrip.github.io/DRIP-Numerical-Optimizer/
  30.  *  - DRIP Statistical Learning - https://lakshmidrip.github.io/DRIP-Statistical-Learning/
  31.  * 
  32.  *  - DRIP Fixed Income: Library for Instrument/Trading Conventions, Treasury Futures/Options,
  33.  *      Funding/Forward/Overnight Curves, Multi-Curve Construction/Valuation, Collateral Valuation and XVA
  34.  *      Metric Generation, Calibration and Hedge Attributions, Statistical Curve Construction, Bond RV
  35.  *      Metrics, Stochastic Evolution and Option Pricing, Interest Rate Dynamics and Option Pricing, LMM
  36.  *      Extensions/Calibrations/Greeks, Algorithmic Differentiation, and Asset Backed Models and Analytics.
  37.  * 
  38.  *  - DRIP Asset Allocation: Library for model libraries for MPT framework, Black Litterman Strategy
  39.  *      Incorporator, Holdings Constraint, and Transaction Costs.
  40.  * 
  41.  *  - DRIP Numerical Optimizer: Library for Numerical Optimization and Spline Functionality.
  42.  * 
  43.  *  - DRIP Statistical Learning: Library for Statistical Evaluation and Machine Learning.
  44.  * 
  45.  *  Licensed under the Apache License, Version 2.0 (the "License");
  46.  *      you may not use this file except in compliance with the License.
  47.  *   
  48.  *  You may obtain a copy of the License at
  49.  *      http://www.apache.org/licenses/LICENSE-2.0
  50.  *  
  51.  *  Unless required by applicable law or agreed to in writing, software
  52.  *      distributed under the License is distributed on an "AS IS" BASIS,
  53.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  54.  *  
  55.  *  See the License for the specific language governing permissions and
  56.  *      limitations under the License.
  57.  */

  59. /**
  60.  * PolynomialBasisSpline implements Samples for the Construction and the usage of polynomial (both regular
  61.  *  and Hermite) basis spline functions. It demonstrates the following:
  62.  *  - Control the polynomial segment using the rational shape controller, the appropriate Ck, and the basis
  63.  *      function.
  64.  *  - Demonstrate the variational shape optimization behavior.
  65.  *  - Estimate the node value and the node value Jacobian with the segment, as well as at the boundaries.
  66.  *  - Calculate the segment monotonicity and the curvature penalty.
  67.  *
  68.  * @author Lakshmi Krishnamurthy
  69.  */

  71. public class PolynomialBasisSpline {

  73.     /*
  74.      * This sample demonstrates the following:
  75.      * 
  76.      *  - Construction of two segments, 1 and 2.
  77.      *  - Calibration of the segments to the left and the right node values
  78.      *  - Extraction of the segment Jacobians and segment monotonicity
  79.      *  - Estimate point value and the Jacobian, monotonicity, and curvature penalty
  80.      * 
  81.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  82.      */

  84.     private static final void TestPolynomialSpline (
  85.         final int iNumBasis,
  86.         final int iCk,
  87.         final int iRoughnessPenaltyDerivativeOrder,
  88.         final ResponseScalingShapeControl rssc)
  89.         throws Exception
  90.     {
  91.         System.out.println (" ------------------------------ \n     POLYNOMIAL n = " + iNumBasis +
  92.             "; Ck = " + iCk + "\n ------------------------------ \n");

  94.         /*
  95.          * Construct the segment inelastic parameter that is C2 (iCk = 2 sets it to C2), without constraint
  96.          */

  98.         SegmentInelasticDesignControl sdic = SegmentInelasticDesignControl.Create (
  99.             iCk,
  100.             iRoughnessPenaltyDerivativeOrder
  101.         );

  103.         /*
  104.          * Create the basis parameter set from the number of basis functions, and construct the basis
  105.          */

  107.         PolynomialFunctionSetParams pfsp = new PolynomialFunctionSetParams (iNumBasis);

  109.         FunctionSet fs = FunctionSetBuilder.PolynomialBasisSet (pfsp);

  111.         /*
  112.          * Construct the left and the right segments
  113.          */

  115.         LatentStateResponseModel ecs1 = LatentStateResponseModel.Create (
  116.             1.0,
  117.             1.5,
  118.             fs,
  119.             rssc,
  120.             sdic
  121.         );

  123.         LatentStateResponseModel ecs2 = LatentStateResponseModel.Create (
  124.             1.5,
  125.             2.0,
  126.             fs,
  127.             rssc,
  128.             sdic
  129.         );

  131.         /*
  132.          * Calibrate the left segment using the node values, and compute the segment Jacobian, monotonicity, and curvature penalty
  133.          */

  135.         WengertJacobian wj1 = ecs1.jackDCoeffDEdgeParams (
  136.             25.,
  137.             0.,
  138.             20.25,
  139.             null
  140.         );

  142.         System.out.println ("\tY[" + 1.0 + "]: " + ecs1.responseValue (1.));

  144.         System.out.println ("\tY[" + 1.5 + "]: " + ecs1.responseValue (1.5));

  146.         System.out.println ("Segment 1 Jacobian: " + wj1.displayString());

  148.         System.out.println ("Segment 1 Head: " + ecs1.jackDCoeffDEdgeInputs().displayString());

  150.         System.out.println ("Segment 1 Monotone Type: " + ecs1.monotoneType());

  152.         System.out.println ("Segment 1 DPE: " + ecs1.curvatureDPE());

  154.         /*
  155.          * Calibrate the right segment using the node values, and compute the segment Jacobian, monotonicity, and curvature penalty
  156.          */

  158.         WengertJacobian wj2 = ecs2.jackDCoeffDEdgeParams (
  159.             ecs1,
  160.             "Default",
  161.             16.,
  162.             null,
  163.             Double.NaN,
  164.             null
  165.         );

  167.         System.out.println ("\tY[" + 1.5 + "]: " + ecs2.responseValue (1.5));

  169.         System.out.println ("\tY[" + 2. + "]: " + ecs2.responseValue (2.));

  171.         System.out.println ("Segment 2 Jacobian: " + wj2.displayString());

  173.         System.out.println ("Segment 2 Regular Jacobian: " + ecs2.jackDCoeffDEdgeInputs().displayString());

  175.         System.out.println ("Segment 2 Monotone Type: " + ecs2.monotoneType());

  177.         System.out.println ("Segment 2 DPE: " + ecs2.curvatureDPE());

  179.         /*
  180.          * Re-calibrate Segment #2 with a new Response Value
  181.          */

  183.         ecs2.calibrate (
  184.             ecs1,
  185.             14.,
  186.             null
  187.         );

  189.         /*
  190.          * Estimate the segment value at the given variate, and compute the corresponding Jacobian, and curvature penalty
  191.          */

  193.         double dblX = 2.0;

  195.         System.out.println ("\t\tValue[" + dblX + "]: " + ecs2.responseValue (dblX));

  197.         System.out.println ("\t\tValue Jacobian[" + dblX + "]: " + ecs2.jackDResponseDEdgeInput (dblX, 1).displayString());

  199.         System.out.println ("\t\tSegment 2 DPE: " + ecs2.curvatureDPE());
  200.     }

  202.     /*
  203.      * This sample demonstrates the following specifically for the Ck Hermite Splines, which are calibrated
  204.      *  using left and right node values, along with their derivatives:
  205.      * 
  206.      *  - Construction of two segments, 1 and 2.
  207.      *  - Calibration of the segments to the left and the right node values
  208.      *  - Extraction of the segment Jacobians and segment monotonicity
  209.      *  - Estimate point value and the Jacobian, monotonicity, and curvature penalty
  210.      * 
  211.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  212.      */

  214.     private static final void TestC1HermiteSpline (
  215.         final int iNumBasis,
  216.         final int iCk,
  217.         final int iRoughnessPenaltyDerivativeOrder,
  218.         final ResponseScalingShapeControl rssc)
  219.         throws Exception
  220.     {
  221.         System.out.println (" ------------------------------ \n     HERMITE POLYNOMIAL n = " + iNumBasis +
  222.             "; Ck = " + iCk + "\n ------------------------------ \n");

  224.         /*
  225.          * Construct the segment inelastic parameter that is C2 (iCk = 2 sets it to C2), without constraint
  226.          */

  228.         SegmentInelasticDesignControl sdic = SegmentInelasticDesignControl.Create (
  229.             iCk,
  230.             iRoughnessPenaltyDerivativeOrder
  231.         );

  233.         /*
  234.          * Create the basis parameter set from the number of basis functions, and construct the basis
  235.          */

  237.         PolynomialFunctionSetParams pfsp = new PolynomialFunctionSetParams (iNumBasis);

  239.         FunctionSet fs = FunctionSetBuilder.PolynomialBasisSet (pfsp);

  241.         /*
  242.          * Construct the left and the right segments
  243.          */

  245.         LatentStateResponseModel ecs1 = LatentStateResponseModel.Create (
  246.             0.0,
  247.             1.0,
  248.             fs,
  249.             rssc,
  250.             sdic
  251.         );

  253.         LatentStateResponseModel ecs2 = LatentStateResponseModel.Create (
  254.             1.0,
  255.             2.0,
  256.             fs,
  257.             rssc,
  258.             sdic
  259.         );

  261.         /*
  262.          * Calibrate the left segment using the node values, and compute the segment Jacobian, monotonicity, and curvature penalty
  263.          */

  265.         ecs1.calibrateState (
  266.             new SegmentStateCalibrationInputs (
  267.                 new double[] {0., 1.}, // Segment Calibration Nodes
  268.                 new double[] {1., 4.}, // Segment Calibration Values
  269.                 new double[] {1.}, // Segment Left Derivative
  270.                 new double[] {6.}, // Segment Left Derivative
  271.                 null,
  272.                 null // Segment Constraint AND Fitness Penalty Response
  273.             )
  274.         );

  276.         System.out.println ("\tY[" + 0.0 + "]: " + ecs1.responseValue (0.0));

  278.         System.out.println ("\tY[" + 1.0 + "]: " + ecs1.responseValue (1.0));

  280.         System.out.println ("Segment 1 Head: " + ecs1.jackDCoeffDEdgeInputs().displayString());

  282.         System.out.println ("Segment 1 Monotone Type: " + ecs1.monotoneType());

  284.         System.out.println ("Segment 1 DPE: " + ecs1.curvatureDPE());

  286.         /*
  287.          * Calibrate the right segment using the node values, and compute the segment Jacobian, monotonicity, and curvature penalty
  288.          */

  290.         ecs2.calibrateState (
  291.             new SegmentStateCalibrationInputs (
  292.                 new double[] {1., 2.}, // Segment Calibration Nodes
  293.                 new double[] {4., 15.}, // Segment Calibration Values
  294.                 new double[] {6.}, // Segment Left Derivative
  295.                 new double[] {17.}, // Segment Left Derivative
  296.                 null, // Segment Constraint
  297.                 null // Fitness Penalty Response
  298.             )
  299.         );

  301.         System.out.println ("\tY[" + 1.0 + "]: " + ecs2.responseValue (1.0));

  303.         System.out.println ("\tY[" + 2.0 + "]: " + ecs2.responseValue (2.0));

  305.         System.out.println ("Segment 2 Regular Jacobian: " + ecs2.jackDCoeffDEdgeInputs().displayString());

  307.         System.out.println ("Segment 2 Monotone Type: " + ecs2.monotoneType());

  309.         System.out.println ("Segment 2 DPE: " + ecs2.curvatureDPE());

  311.         /*
  312.          * Re-calibrate Segment #2 with a new Response Value
  313.          */

  315.         ecs2.calibrate (
  316.             ecs1,
  317.             14.,
  318.             null
  319.         );

  321.         /*
  322.          * Estimate the segment value at the given variate, and compute the corresponding Jacobian, monotonicity, and curvature penalty
  323.          */

  325.         double dblX = 2.0;

  327.         System.out.println ("\t\tValue[" + dblX + "]: " + ecs2.responseValue (dblX));

  329.         System.out.println ("\t\tValue Jacobian[" + dblX + "]: " + ecs2.jackDResponseDEdgeInput (dblX, 1).displayString());

  331.         System.out.println ("\t\tSegment 2 DPE: " + ecs2.curvatureDPE());
  332.     }

  334.     /*
  335.      * This sample illustrates the construction and usage for polynomial basis splines. It shows the
  336.      *  following:
  337.      *  - Construct a rational shape controller with the specified shape controller tension.
  338.      *  - Set the Roughness Penalty to 2nd order Roughness Penalty Derivative Order.
  339.      *  - Test the polynomial spline across different polynomial degrees and Ck's.
  340.      *  - Test the C1 Hermite spline.
  341.      * 
  342.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  343.      */

  345.     private static final void PolynomialBasisSplineSample()
  346.         throws Exception
  347.     {
  348.         /*
  349.          * Construct a rational shape controller with the shape controller tension of 1.
  350.          */

  352.         double dblShapeControllerTension = 1.;

  354.         ResponseScalingShapeControl rssc = new ResponseScalingShapeControl (
  355.             true,
  356.             new QuadraticRationalShapeControl (dblShapeControllerTension)
  357.         );

  359.         /*
  360.          * Set to 2nd order Roughness Penalty Derivative Order.
  361.          */

  363.         int iRoughnessPenaltyDerivativeOrder = 2;

  365.         /*
  366.          * Test the polynomial spline across different polynomial degrees and Ck's
  367.          */

  369.         TestPolynomialSpline (2, 0, iRoughnessPenaltyDerivativeOrder, rssc);

  371.         TestPolynomialSpline (3, 0, iRoughnessPenaltyDerivativeOrder, rssc);

  373.         TestPolynomialSpline (3, 1, iRoughnessPenaltyDerivativeOrder, rssc);

  375.         TestPolynomialSpline (4, 0, iRoughnessPenaltyDerivativeOrder, rssc);

  377.         TestPolynomialSpline (4, 1, iRoughnessPenaltyDerivativeOrder, rssc);

  379.         TestPolynomialSpline (4, 2, iRoughnessPenaltyDerivativeOrder, rssc);

  381.         TestPolynomialSpline (5, 0, iRoughnessPenaltyDerivativeOrder, rssc);

  383.         TestPolynomialSpline (5, 1, iRoughnessPenaltyDerivativeOrder, rssc);

  385.         TestPolynomialSpline (5, 2, iRoughnessPenaltyDerivativeOrder, rssc);

  387.         TestPolynomialSpline (5, 3, iRoughnessPenaltyDerivativeOrder, rssc);

  389.         TestPolynomialSpline (6, 0, iRoughnessPenaltyDerivativeOrder, rssc);

  391.         TestPolynomialSpline (6, 1, iRoughnessPenaltyDerivativeOrder, rssc);

  393.         TestPolynomialSpline (6, 2, iRoughnessPenaltyDerivativeOrder, rssc);

  395.         TestPolynomialSpline (6, 3, iRoughnessPenaltyDerivativeOrder, rssc);

  397.         TestPolynomialSpline (6, 4, iRoughnessPenaltyDerivativeOrder, rssc);

  399.         TestPolynomialSpline (7, 0, iRoughnessPenaltyDerivativeOrder, rssc);

  401.         TestPolynomialSpline (7, 1, iRoughnessPenaltyDerivativeOrder, rssc);

  403.         TestPolynomialSpline (7, 2, iRoughnessPenaltyDerivativeOrder, rssc);

  405.         TestPolynomialSpline (7, 3, iRoughnessPenaltyDerivativeOrder, rssc);

  407.         TestPolynomialSpline (7, 4, iRoughnessPenaltyDerivativeOrder, rssc);

  409.         TestPolynomialSpline (7, 5, iRoughnessPenaltyDerivativeOrder, rssc);

  411.         /*
  412.          * Test the C1 Hermite spline
  413.          */

  415.         System.out.println (" -------------------- \n Ck HERMITE \n -------------------- \n");

  417.         TestC1HermiteSpline (4, 1, iRoughnessPenaltyDerivativeOrder, rssc);
  418.     }

  420.     public static final void main (
  421.         final String[] astrArgs)
  422.         throws Exception
  423.     {
  424.         PolynomialBasisSplineSample();
  425.     }
  426. }
Created with JaCoCo 0.7.9.201702052155