KochLycheKvasovFamily.java

  1. package org.drip.spline.tension;

  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>KochLycheKvasovFamily</i> implements the basic framework and the family of C2 Tension Splines outlined
  85.  * in Koch and Lyche (1989), Koch and Lyche (1993), and Kvasov (2000) Papers. Functions exposed here
  86.  * implement the Basis Function Set from:
  87.  *
  88.  *  <br><br>
  89.  *  <ul>
  90.  *      <li>
  91.  *          Hyperbolic Hat Primitive Set
  92.  *      </li>
  93.  *      <li>
  94.  *          Cubic Polynomial Numerator and Linear Rational Denominator
  95.  *      </li>
  96.  *      <li>
  97.  *          Cubic Polynomial Numerator and Quadratic Rational Denominator
  98.  *      </li>
  99.  *      <li>
  100.  *          Cubic Polynomial Numerator and Exponential Denominator
  101.  *      </li>
  102.  *  </ul>
  103.  *
  104.  *  <br><br>
  105.  *  <ul>
  106.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  107.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/SplineBuilderLibrary.md">Spline Builder Library</a></li>
  108.  *      <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>
  109.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spline/tension/README.md">Koch Lyche Kvasov Tension Splines</a></li>
  110.  *  </ul>
  111.  * <br><br>
  112.  * 
  113.  * @author Lakshmi Krishnamurthy
  114.  */

  116. public class KochLycheKvasovFamily {

  118.     /**
  119.      * Implement the Basis Function Set from the Hyperbolic Hat Primitive Set
  120.      * 
  121.      * @param etsp The Tension Function Set Parameters
  122.      * 
  123.      * @return Instance of the Basis Function Set
  124.      */

  126.     public static final org.drip.spline.basis.FunctionSet FromHyperbolicPrimitive (
  127.         final org.drip.spline.basis.ExponentialTensionSetParams etsp)
  128.     {
  129.         if (null == etsp) return null;

  131.         org.drip.function.definition.R1ToR1 auPhy = new org.drip.function.definition.R1ToR1
  132.             (null) {
  133.             @Override public double evaluate (
  134.                 final double dblX)
  135.                 throws java.lang.Exception
  136.             {
  137.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  138.                     throw new java.lang.Exception
  139.                         ("KLKF::FromHyperbolicPrimitive.Phy::evaluate => Invalid Inputs!");

  141.                 double dblTension = etsp.tension();

  143.                 return (java.lang.Math.sinh (dblTension * dblX) - dblTension * dblX) / (dblTension *
  144.                     dblTension * java.lang.Math.sinh (dblTension));
  145.             }

  147.             @Override public double derivative (
  148.                 final double dblX,
  149.                 final int iOrder)
  150.                 throws java.lang.Exception
  151.             {
  152.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  153.                     throw new java.lang.Exception
  154.                         ("KLKF::FromHyperbolicPrimitive.Phy::derivative => Invalid Inputs!");

  156.                 double dblTension = etsp.tension();

  158.                 if (1 == iOrder)
  159.                     return (java.lang.Math.cosh (dblTension * dblX) - 1.) / (dblTension * java.lang.Math.sinh
  160.                         (dblTension));

  162.                 if (2 == iOrder)
  163.                     return java.lang.Math.sinh (dblTension * dblX) / java.lang.Math.sinh (dblTension);

  165.                 return derivative (dblX, iOrder);
  166.             }

  168.             @Override public double integrate (
  169.                 final double dblBegin,
  170.                 final double dblEnd)
  171.                 throws java.lang.Exception
  172.             {
  173.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblBegin) ||
  174.                     !org.drip.numerical.common.NumberUtil.IsValid (dblEnd))
  175.                     throw new java.lang.Exception
  176.                         ("KLKF::FromHyperbolicPrimitive.Phy::integrate => Invalid Inputs");

  178.                 double dblTension = etsp.tension();

  180.                 return (java.lang.Math.cosh (dblTension * dblEnd) - java.lang.Math.cosh (dblTension *
  181.                     dblBegin) - 0.5 * dblTension * (dblEnd * dblEnd - dblBegin * dblBegin)) / (dblTension *
  182.                         dblTension * dblTension * java.lang.Math.sinh (dblTension));
  183.             }
  184.         };

  186.         org.drip.function.definition.R1ToR1 auPsy = new org.drip.function.definition.R1ToR1
  187.             (null) {
  188.             @Override public double evaluate (
  189.                 final double dblX)
  190.                 throws java.lang.Exception
  191.             {
  192.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  193.                     throw new java.lang.Exception
  194.                         ("KLKF.Psy::FromHyperbolicPrimitive::evaluate => Invalid Inputs!");

  196.                 double dblTension = etsp.tension();

  198.                 return (java.lang.Math.sinh (dblTension * (1. - dblX)) - dblTension * (1. - dblX)) /
  199.                     (dblTension * dblTension * java.lang.Math.sinh (dblTension));
  200.             }

  202.             @Override public double derivative (
  203.                 final double dblX,
  204.                 final int iOrder)
  205.                 throws java.lang.Exception
  206.             {
  207.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  208.                     throw new java.lang.Exception
  209.                         ("KLKF::FromHyperbolicPrimitive.Psy::derivative => Invalid Inputs!");

  211.                 double dblTension = etsp.tension();

  213.                 if (1 == iOrder)
  214.                     return (1. - java.lang.Math.cosh (dblTension * (1. - dblX))) / (dblTension *
  215.                         java.lang.Math.cosh (dblTension));

  217.                 if (2 == iOrder)
  218.                     return java.lang.Math.sinh (dblTension * (1. - dblX)) / java.lang.Math.sinh (dblTension);

  220.                 return derivative (dblX, iOrder);
  221.             }

  223.             @Override public double integrate (
  224.                 final double dblBegin,
  225.                 final double dblEnd)
  226.                 throws java.lang.Exception
  227.             {
  228.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblBegin) ||
  229.                     !org.drip.numerical.common.NumberUtil.IsValid (dblEnd))
  230.                     throw new java.lang.Exception
  231.                         ("KLKF::FromHyperbolicPrimitive.Psy::integrate => Invalid Inputs");

  233.                 double dblTension = etsp.tension();

  235.                 return -1. * (java.lang.Math.sinh (dblTension * (1. - dblEnd)) - java.lang.Math.sinh 
  236.                     (dblTension * (1. - dblBegin)) - 0.5 * dblTension * ((1. - dblEnd) * (1. - dblEnd) - (1.
  237.                         - dblBegin) * (1. - dblBegin))) / (dblTension * dblTension * dblTension *
  238.                             java.lang.Math.sinh (dblTension));
  239.             }
  240.         };

  242.         try {
  243.             return new org.drip.spline.bspline.SegmentBasisFunctionSet (2, etsp.tension(), new
  244.                 org.drip.function.definition.R1ToR1[] {auPhy, auPsy});
  245.         } catch (java.lang.Exception e) {
  246.             e.printStackTrace();
  247.         }

  249.         return null;
  250.     }

  252.     /**
  253.      * Implement the Basis Function Set from the Cubic Polynomial Numerator and Linear Rational Denominator
  254.      * 
  255.      * @param etsp The Tension Function Set Parameters
  256.      * 
  257.      * @return Instance of the Basis Function Set
  258.      */

  260.     public static final org.drip.spline.basis.FunctionSet FromRationalLinearPrimitive (
  261.         final org.drip.spline.basis.ExponentialTensionSetParams etsp)
  262.     {
  263.         if (null == etsp) return null;

  265.         org.drip.function.definition.R1ToR1 auPhy = new org.drip.function.definition.R1ToR1
  266.             (null) {
  267.             @Override public double evaluate (
  268.                 final double dblX)
  269.                 throws java.lang.Exception
  270.             {
  271.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  272.                     throw new java.lang.Exception
  273.                         ("KLKF::FromRationalLinearPrimitive.Phy::evaluate => Invalid Inputs!");

  275.                 double dblTension = etsp.tension();

  277.                 return dblX * dblX * dblX / (1. + dblTension * (1. - dblX)) / (6. + 8. * dblTension);
  278.             }

  280.             @Override public double derivative (
  281.                 final double dblX,
  282.                 final int iOrder)
  283.                 throws java.lang.Exception
  284.             {
  285.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  286.                     throw new java.lang.Exception
  287.                         ("KLKF::FromRationalLinearPrimitive.Phy::derivative => Invalid Inputs!");

  289.                 double dblTension = etsp.tension();

  291.                 if (1 == iOrder) {
  292.                     double dblDLDX = -1. * dblTension;
  293.                     double dblL = 1. + dblTension * (1. - dblX);

  295.                     return 1. / (dblL * dblL * (6. + 8. * dblTension)) * (3. * dblL * dblX * dblX - dblDLDX *
  296.                         dblX * dblX * dblX);
  297.                 }

  299.                 if (2 == iOrder) {
  300.                     double dblD2LDX2 = 0.;
  301.                     double dblDLDX = -1. * dblTension;
  302.                     double dblL = 1. + dblTension * (1. - dblX);

  304.                     return 1. / (dblL * dblL * (6. + 8. * dblTension)) * (6. * dblL * dblX - dblD2LDX2 * dblX
  305.                         * dblX * dblX) - 2. / (dblL * dblL * dblL * (6. + 8. * dblTension)) *
  306.                             (3. * dblL * dblX * dblX - dblDLDX * dblX * dblX * dblX);
  307.                 }

  309.                 return derivative (dblX, iOrder);
  310.             }

  312.             @Override public double integrate (
  313.                 final double dblBegin,
  314.                 final double dblEnd)
  315.                 throws java.lang.Exception
  316.             {
  317.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  318.             }
  319.         };

  321.         org.drip.function.definition.R1ToR1 auPsy = new org.drip.function.definition.R1ToR1
  322.             (null) {
  323.             @Override public double evaluate (
  324.                 final double dblX)
  325.                 throws java.lang.Exception
  326.             {
  327.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  328.                     throw new java.lang.Exception
  329.                         ("KLKF::FromRationalLinearPrimitive.Psy::evaluate => Invalid Inputs!");

  331.                 double dblTension = etsp.tension();

  333.                 return (1. - dblX) * (1. - dblX) * (1. - dblX) / (1. + dblTension * dblX) / (6. + 8. *
  334.                     dblTension);
  335.             }

  337.             @Override public double derivative (
  338.                 final double dblX,
  339.                 final int iOrder)
  340.                 throws java.lang.Exception
  341.             {
  342.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  343.                     throw new java.lang.Exception
  344.                         ("KLKF::FromRationalLinearPrimitive.Psy::derivative => Invalid Inputs!");

  346.                 double dblTension = etsp.tension();

  348.                 if (1 == iOrder) {
  349.                     double dblDLDX = dblTension;
  350.                     double dblL = 1. + dblTension * dblX;

  352.                     return -1. / (dblL * dblL * (6. + 8. * dblTension)) * (3. * dblL * (1. - dblX) *
  353.                         (1. - dblX) + dblDLDX * (1. - dblX) * (1. - dblX) * (1. - dblX));
  354.                 }

  356.                 if (2 == iOrder) {
  357.                     double dblD2LDX2 = 0.;
  358.                     double dblDLDX = dblTension;
  359.                     double dblL = 1. + dblTension * dblX;

  361.                     return 1. / (dblL * dblL * (6. + 8. * dblTension)) * (6. * dblL * (1. - dblX) - dblD2LDX2
  362.                         * (1. - dblX) * (1. - dblX) * (1. - dblX)) - 2. / (dblL * dblL * dblL *
  363.                             (6. + 8. * dblTension)) * (3. * dblL * (1. - dblX) * (1. - dblX) + dblDLDX *
  364.                                 (1. - dblX) * (1. - dblX) * (1. - dblX));
  365.                 }

  367.                 return derivative (dblX, iOrder);
  368.             }

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

  379.         try {
  380.             return new org.drip.spline.bspline.SegmentBasisFunctionSet (2, etsp.tension(), new
  381.                 org.drip.function.definition.R1ToR1[] {auPhy, auPsy});
  382.         } catch (java.lang.Exception e) {
  383.             e.printStackTrace();
  384.         }

  386.         return null;
  387.     }

  389.     /**
  390.      * Implement the Basis Function Set from the Cubic Polynomial Numerator and Quadratic Rational
  391.      *  Denominator
  392.      * 
  393.      * @param etsp The Tension Function Set Parameters
  394.      * 
  395.      * @return Instance of the Basis Function Set
  396.      */

  398.     public static final org.drip.spline.basis.FunctionSet FromRationalQuadraticPrimitive (
  399.         final org.drip.spline.basis.ExponentialTensionSetParams etsp)
  400.     {
  401.         if (null == etsp) return null;

  403.         org.drip.function.definition.R1ToR1 auPhy = new org.drip.function.definition.R1ToR1
  404.             (null) {
  405.             @Override public double evaluate (
  406.                 final double dblX)
  407.                 throws java.lang.Exception
  408.             {
  409.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  410.                     throw new java.lang.Exception
  411.                         ("KLKF::FromRationalQuadraticPrimitive.Phy::evaluate => Invalid Inputs!");

  413.                 double dblTension = etsp.tension();

  415.                 return dblX * dblX * dblX / (1. + dblTension * dblX * (1. - dblX)) / (6. + 8. * dblTension);
  416.             }

  418.             @Override public double derivative (
  419.                 final double dblX,
  420.                 final int iOrder)
  421.                 throws java.lang.Exception
  422.             {
  423.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  424.                     throw new java.lang.Exception
  425.                         ("KLKF::FromRationalQuadraticPrimitive.Phy::derivative => Invalid Inputs!");

  427.                 double dblTension = etsp.tension();

  429.                 if (1 == iOrder) {
  430.                     double dblDLDX = dblTension * (1. - 2. * dblX);
  431.                     double dblL = 1. + dblTension * dblX * (1. - dblX);

  433.                     return 1. / (dblL * dblL * (6. + 8. * dblTension)) * (3. * dblL * dblX * dblX - dblDLDX *
  434.                         dblX * dblX * dblX);
  435.                 }

  437.                 if (2 == iOrder) {
  438.                     double dblD2LDX2 = -2. * dblTension;
  439.                     double dblDLDX = dblTension * (1. - 2. * dblX);
  440.                     double dblL = 1. + dblTension * dblX * (1. - dblX);

  442.                     return 1. / (dblL * dblL * (6. + 8. * dblTension)) * (6. * dblL * dblX - dblD2LDX2 * dblX
  443.                         * dblX * dblX) - 2. / (dblL * dblL * dblL * (6. + 8. * dblTension)) *
  444.                             (3. * dblL * dblX * dblX - dblDLDX * dblX * dblX * dblX);
  445.                 }

  447.                 return derivative (dblX, iOrder);
  448.             }

  450.             @Override public double integrate (
  451.                 final double dblBegin,
  452.                 final double dblEnd)
  453.                 throws java.lang.Exception
  454.             {
  455.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  456.             }
  457.         };

  459.         org.drip.function.definition.R1ToR1 auPsy = new org.drip.function.definition.R1ToR1
  460.             (null) {
  461.             @Override public double evaluate (
  462.                 final double dblX)
  463.                 throws java.lang.Exception
  464.             {
  465.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  466.                     throw new java.lang.Exception
  467.                         ("KLKF::FromRationalQuadraticPrimitive.Psy::evaluate => Invalid Inputs!");

  469.                 double dblTension = etsp.tension();

  471.                 return (1. - dblX) * (1. - dblX) * (1. - dblX) / (1. + dblTension * dblX * (1. - dblX)) / (6.
  472.                     + 8. * dblTension);
  473.             }

  475.             @Override public double derivative (
  476.                 final double dblX,
  477.                 final int iOrder)
  478.                 throws java.lang.Exception
  479.             {
  480.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  481.                     throw new java.lang.Exception
  482.                         ("KLKF::FromRationalQuadraticPrimitive.Psy::derivative => Invalid Inputs!");

  484.                 double dblTension = etsp.tension();

  486.                 if (1 == iOrder) {
  487.                     double dblDLDX = dblTension * (1. - 2. * dblX);
  488.                     double dblL = 1. + dblTension * dblX * (1. - dblX);

  490.                     return -1. / (dblL * dblL * (6. + 8. * dblTension)) * (3. * dblL * (1. - dblX) *
  491.                         (1. - dblX) + dblDLDX * (1. - dblX) * (1. - dblX) * (1. - dblX));
  492.                 }

  494.                 if (2 == iOrder) {
  495.                     double dblD2LDX2 = -2. * dblTension * dblX;
  496.                     double dblDLDX = dblTension * (1. - 2. * dblX);
  497.                     double dblL = 1. + dblTension * dblX * (1. - dblX);

  499.                     return 1. / (dblL * dblL * (6. + 8. * dblTension)) * (6. * dblL * (1. - dblX) - dblD2LDX2
  500.                         * (1. - dblX) * (1. - dblX) * (1. - dblX)) - 2. / (dblL * dblL * dblL *
  501.                             (6. + 8. * dblTension)) * (3. * dblL * (1. - dblX) * (1. - dblX) + dblDLDX *
  502.                                 (1. - dblX) * (1. - dblX) * (1. - dblX));
  503.                 }

  505.                 return derivative (dblX, iOrder);
  506.             }

  508.             @Override public double integrate (
  509.                 final double dblBegin,
  510.                 final double dblEnd)
  511.                 throws java.lang.Exception
  512.             {
  513.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  514.             }
  515.         };

  517.         try {
  518.             return new org.drip.spline.bspline.SegmentBasisFunctionSet (2, etsp.tension(), new
  519.                 org.drip.function.definition.R1ToR1[] {auPhy, auPsy});
  520.         } catch (java.lang.Exception e) {
  521.             e.printStackTrace();
  522.         }

  524.         return null;
  525.     }

  527.     /**
  528.      * Implement the Basis Function Set from the Cubic Polynomial Numerator and Exponential Denominator
  529.      * 
  530.      * @param etsp The Tension Function Set Parameters
  531.      * 
  532.      * @return Instance of the Basis Function Set
  533.      */

  535.     public static final org.drip.spline.basis.FunctionSet FromExponentialPrimitive (
  536.         final org.drip.spline.basis.ExponentialTensionSetParams etsp)
  537.     {
  538.         if (null == etsp) return null;

  540.         org.drip.function.definition.R1ToR1 auPhy = new org.drip.function.definition.R1ToR1
  541.             (null) {
  542.             @Override public double evaluate (
  543.                 final double dblX)
  544.                 throws java.lang.Exception
  545.             {
  546.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  547.                     throw new java.lang.Exception
  548.                         ("KLKF::FromExponentialPrimitive.Phy::evaluate => Invalid Inputs!");

  550.                 double dblTension = etsp.tension();

  552.                 return dblX * dblX * dblX * java.lang.Math.exp (-1. * dblTension * (1. - dblX)) / (6. + 7. *
  553.                     dblTension);
  554.             }

  556.             @Override public double derivative (
  557.                 final double dblX,
  558.                 final int iOrder)
  559.                 throws java.lang.Exception
  560.             {
  561.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  562.                     throw new java.lang.Exception
  563.                         ("KLKF::FromExponentialPrimitive.Phy::derivative => Invalid Inputs!");

  565.                 double dblTension = etsp.tension();

  567.                 if (1 == iOrder)
  568.                     return (3. + dblTension * dblX) / (6. + 7. * dblTension) * dblX * dblX *
  569.                         java.lang.Math.exp (-1. * dblTension * (1. - dblX));

  571.                 if (2 == iOrder)
  572.                     return (dblTension * dblTension * dblX * dblX + 6. * dblTension * dblX + 6.) / (6. + 7. *
  573.                         dblTension) * dblX * java.lang.Math.exp (-1. * dblTension * (1. - dblX));

  575.                 return derivative (dblX, iOrder);
  576.             }

  578.             @Override public double integrate (
  579.                 final double dblBegin,
  580.                 final double dblEnd)
  581.                 throws java.lang.Exception
  582.             {
  583.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  584.             }
  585.         };

  587.         org.drip.function.definition.R1ToR1 auPsy = new org.drip.function.definition.R1ToR1
  588.             (null) {
  589.             @Override public double evaluate (
  590.                 final double dblX)
  591.                 throws java.lang.Exception
  592.             {
  593.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  594.                     throw new java.lang.Exception
  595.                         ("KLKF::FromExponentialPrimitive.Psy::evaluate => Invalid Inputs!");

  597.                 double dblTension = etsp.tension();

  599.                 return (1. - dblX) * (1. - dblX) * (1. - dblX) * java.lang.Math.exp (-1. * dblTension * dblX)
  600.                     / (6. + 7. * dblTension);
  601.             }

  603.             @Override public double derivative (
  604.                 final double dblX,
  605.                 final int iOrder)
  606.                 throws java.lang.Exception
  607.             {
  608.                 if (!org.drip.numerical.common.NumberUtil.IsValid (dblX))
  609.                     throw new java.lang.Exception
  610.                         ("KLKF::FromExponentialPrimitive.Psy::derivative => Invalid Inputs!");

  612.                 double dblTension = etsp.tension();

  614.                 if (1 == iOrder)
  615.                     return -1. * (3. + dblTension * (1. - dblX)) / (6. + 7. * dblTension) * (1. - dblX) *
  616.                         (1. - dblX) * java.lang.Math.exp (-1. * dblTension * dblX);

  618.                 if (2 == iOrder)
  619.                     return (dblTension * dblTension * (1. - dblX) * (1. - dblX) + 6. * dblTension *
  620.                         (1. - dblX) + 6.) / (6. + 7. * dblTension) * (1. - dblX) * java.lang.Math.exp (-1. *
  621.                             dblTension * dblX);

  623.                 return derivative (dblX, iOrder);
  624.             }

  626.             @Override public double integrate (
  627.                 final double dblBegin,
  628.                 final double dblEnd)
  629.                 throws java.lang.Exception
  630.             {
  631.                 return org.drip.numerical.integration.R1ToR1Integrator.Boole (this, dblBegin, dblEnd);
  632.             }
  633.         };

  635.         try {
  636.             return new org.drip.spline.bspline.SegmentBasisFunctionSet (2, etsp.tension(), new
  637.                 org.drip.function.definition.R1ToR1[] {auPhy, auPsy});
  638.         } catch (java.lang.Exception e) {
  639.             e.printStackTrace();
  640.         }

  642.         return null;
  643.     }
  644. }
Created with JaCoCo 0.7.9.201702052155