InteriorFixedPointFinder.java

  1. package org.drip.function.rdtor1solver;

  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.  * 
  14.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  15.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  16.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  17.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  18.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  19.  *      and computational support.
  20.  *  
  21.  *      https://lakshmidrip.github.io/DROP/
  22.  *  
  23.  *  DROP is composed of three modules:
  24.  *  
  25.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  26.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  27.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  28.  * 
  29.  *  DROP Product Core implements libraries for the following:
  30.  *  - Fixed Income Analytics
  31.  *  - Loan Analytics
  32.  *  - Transaction Cost Analytics
  33.  * 
  34.  *  DROP Portfolio Core implements libraries for the following:
  35.  *  - Asset Allocation Analytics
  36.  *  - Asset Liability Management Analytics
  37.  *  - Capital Estimation Analytics
  38.  *  - Exposure Analytics
  39.  *  - Margin Analytics
  40.  *  - XVA Analytics
  41.  * 
  42.  *  DROP Computational Core implements libraries for the following:
  43.  *  - Algorithm Support
  44.  *  - Computation Support
  45.  *  - Function Analysis
  46.  *  - Model Validation
  47.  *  - Numerical Analysis
  48.  *  - Numerical Optimizer
  49.  *  - Spline Builder
  50.  *  - Statistical Learning
  51.  * 
  52.  *  Documentation for DROP is Spread Over:
  53.  * 
  54.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  55.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  56.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  57.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  58.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  59.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  60.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  61.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  62.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  63.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  64.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  65.  * 
  66.  *  Licensed under the Apache License, Version 2.0 (the "License");
  67.  *      you may not use this file except in compliance with the License.
  68.  *   
  69.  *  You may obtain a copy of the License at
  70.  *      http://www.apache.org/licenses/LICENSE-2.0
  71.  *  
  72.  *  Unless required by applicable law or agreed to in writing, software
  73.  *      distributed under the License is distributed on an "AS IS" BASIS,
  74.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  75.  *  
  76.  *  See the License for the specific language governing permissions and
  77.  *      limitations under the License.
  78.  */

  80. /**
  81.  * <i>InteriorFixedPointFinder</i> generates the Iterators for solving R<sup>d</sup> To R<sup>1</sup>
  82.  * Convex/Non-Convex Functions Under Inequality Constraints loaded using a Barrier Coefficient.
  83.  *
  84.  *  <br><br>
  85.  *  <ul>
  86.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalCore.md">Numerical Core Module</a></li>
  87.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalOptimizerLibrary.md">Numerical Optimizer</a></li>
  88.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/feed/README.md">Function</a></li>
  89.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/feed/rdtor1solver/README.md">R<sup>d</sup> To R<sup>1</sup> Solver</a></li>
  90.  *  </ul>
  91.  *
  92.  * @author Lakshmi Krishnamurthy
  93.  */

  95. public class InteriorFixedPointFinder
  96.     extends org.drip.function.rdtor1solver.FixedRdFinder
  97. {
  98.     private double _barrierStrength = java.lang.Double.NaN;
  99.     private org.drip.function.rdtor1.BoundMultivariate[] _boundMultivariateFunctionArray = null;
  100.     private org.drip.function.definition.RdToR1[] _inequalityConstraintMultivariateFunctionArray = null;

  102.     private org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier incremental (
  103.         final org.drip.function.rdtor1solver.ObjectiveFunctionPointMetrics objectiveFunctionPointMetrics,
  104.         final org.drip.function.rdtor1solver.ConstraintFunctionPointMetrics
  105.             inequalityConstraintFunctionPointMetrics)
  106.     {
  107.         if (null == objectiveFunctionPointMetrics ||
  108.             null == inequalityConstraintFunctionPointMetrics)
  109.         {
  110.             return null;
  111.         }

  113.         int objectiveFunctionDimension = objectiveFunctionPointMetrics.dimension();

  115.         double[] objectiveFunctionJacobian = objectiveFunctionPointMetrics.jacobian();

  117.         double[][] objectiveFunctionHessian = objectiveFunctionPointMetrics.hessian();

  119.         int inequalityConstraintCount = inequalityConstraintFunctionPointMetrics.count();

  121.         double[] variateIncrementArray = new double[objectiveFunctionDimension];
  122.         double[] inequalityConstraintIncrementCount = new double[inequalityConstraintCount];
  123.         int constrainedObjectiveFunctionDimension = objectiveFunctionDimension + inequalityConstraintCount;
  124.         double[][] constrainedObjectiveFunctionJacobianArray =
  125.             new double[constrainedObjectiveFunctionDimension][constrainedObjectiveFunctionDimension];
  126.         double[] constrainedObjectiveFunctionRHSArray = new double[constrainedObjectiveFunctionDimension];

  128.         if (0 == objectiveFunctionDimension ||
  129.             objectiveFunctionDimension != inequalityConstraintFunctionPointMetrics.dimension())
  130.         {
  131.             return null;
  132.         }

  134.         double[] inequalityConstraintFunctionMultiplierArray =
  135.             inequalityConstraintFunctionPointMetrics.constraintFunctionMultiplierArray();

  137.         double[][] inequalityConstraintFunctionJacobianArray =
  138.             inequalityConstraintFunctionPointMetrics.constraintFunctionJacobianArray();

  140.         double[] inequalityConstraintFunctionValueArray =
  141.             inequalityConstraintFunctionPointMetrics.constraintFunctionValueArray();

  143.         for (int objectiveFunctionDimensionIndexI = 0;
  144.             objectiveFunctionDimensionIndexI < objectiveFunctionDimension;
  145.             ++objectiveFunctionDimensionIndexI)
  146.         {
  147.             for (int objectiveFunctionDimensionIndexJ = 0;
  148.                 objectiveFunctionDimensionIndexJ < objectiveFunctionDimension;
  149.                 ++objectiveFunctionDimensionIndexJ)
  150.             {
  151.                 constrainedObjectiveFunctionJacobianArray[objectiveFunctionDimensionIndexI][objectiveFunctionDimensionIndexJ]
  152.                     = objectiveFunctionHessian[objectiveFunctionDimensionIndexI][objectiveFunctionDimensionIndexJ];
  153.             }

  155.             for (int inequalityConstraintIndex = 0;
  156.                 inequalityConstraintIndex < inequalityConstraintCount;
  157.                 ++inequalityConstraintIndex)
  158.             {
  159.                 constrainedObjectiveFunctionJacobianArray[objectiveFunctionDimensionIndexI][inequalityConstraintIndex + objectiveFunctionDimension] =
  160.                     -1. * inequalityConstraintFunctionJacobianArray[objectiveFunctionDimensionIndexI][inequalityConstraintIndex];
  161.             }
  162.         }

  164.         for (int inequalityConstraintIndexI = 0;
  165.             inequalityConstraintIndexI < inequalityConstraintCount;
  166.             ++inequalityConstraintIndexI)
  167.         {
  168.             for (int inequalityConstraintIndexJ = 0;
  169.                 inequalityConstraintIndexJ < inequalityConstraintCount;
  170.                 ++inequalityConstraintIndexJ)
  171.             {
  172.                 constrainedObjectiveFunctionJacobianArray[inequalityConstraintIndexI + objectiveFunctionDimension][inequalityConstraintIndexJ + objectiveFunctionDimension]
  173.                     = inequalityConstraintIndexI == inequalityConstraintIndexJ ? inequalityConstraintFunctionValueArray[inequalityConstraintIndexI] : 0.;
  174.             }

  176.             for (int objectiveFunctionIndex = 0;
  177.                 objectiveFunctionIndex < objectiveFunctionDimension;
  178.                 ++objectiveFunctionIndex)
  179.             {
  180.                 constrainedObjectiveFunctionJacobianArray[inequalityConstraintIndexI + objectiveFunctionDimension][objectiveFunctionIndex] =
  181.                     inequalityConstraintFunctionMultiplierArray[inequalityConstraintIndexI] *
  182.                     inequalityConstraintFunctionJacobianArray[objectiveFunctionIndex][inequalityConstraintIndexI];
  183.             }
  184.         }

  186.         for (int constrainedObjectiveFunctionIndex = 0;
  187.             constrainedObjectiveFunctionIndex < constrainedObjectiveFunctionDimension;
  188.             ++constrainedObjectiveFunctionIndex)
  189.         {
  190.             if (constrainedObjectiveFunctionIndex < objectiveFunctionDimension)
  191.             {
  192.                 constrainedObjectiveFunctionRHSArray[constrainedObjectiveFunctionIndex] =
  193.                     -1. * objectiveFunctionJacobian[constrainedObjectiveFunctionIndex];

  195.                 for (int inequalityConstraintIndex = 0;
  196.                     inequalityConstraintIndex < inequalityConstraintCount;
  197.                     ++inequalityConstraintIndex)
  198.                 {
  199.                     constrainedObjectiveFunctionRHSArray[constrainedObjectiveFunctionIndex] +=
  200.                         inequalityConstraintFunctionJacobianArray[constrainedObjectiveFunctionIndex][inequalityConstraintIndex]
  201.                         * inequalityConstraintFunctionMultiplierArray[inequalityConstraintIndex];
  202.                 }
  203.             }
  204.             else
  205.             {
  206.                 int constraintIndex = constrainedObjectiveFunctionIndex - objectiveFunctionDimension;
  207.                 constrainedObjectiveFunctionRHSArray[constrainedObjectiveFunctionIndex] =
  208.                     _barrierStrength - inequalityConstraintFunctionValueArray[constraintIndex] *
  209.                     inequalityConstraintFunctionMultiplierArray[constraintIndex];
  210.             }
  211.         }

  213.         org.drip.numerical.linearalgebra.LinearizationOutput linearizationOutput =
  214.             org.drip.numerical.linearalgebra.LinearSystemSolver.SolveUsingMatrixInversion (
  215.                 constrainedObjectiveFunctionJacobianArray,
  216.                 constrainedObjectiveFunctionRHSArray
  217.             );

  219.         if (null == linearizationOutput)
  220.         {
  221.             return null;
  222.         }

  224.         double[] variateConstraintIncrementArray = linearizationOutput.getTransformedRHS();

  226.         if (null == variateConstraintIncrementArray ||
  227.             variateConstraintIncrementArray.length != constrainedObjectiveFunctionDimension)
  228.         {
  229.             return null;
  230.         }

  232.         for (int constrainedObjectiveFunctionIndex = 0;
  233.             constrainedObjectiveFunctionIndex < constrainedObjectiveFunctionDimension;
  234.             ++constrainedObjectiveFunctionIndex)
  235.         {
  236.             if (constrainedObjectiveFunctionIndex < objectiveFunctionDimension)
  237.             {
  238.                 variateIncrementArray[constrainedObjectiveFunctionIndex] =
  239.                     variateConstraintIncrementArray[constrainedObjectiveFunctionIndex];
  240.             }
  241.             else
  242.             {
  243.                 inequalityConstraintIncrementCount[constrainedObjectiveFunctionIndex - objectiveFunctionDimension]
  244.                     = variateConstraintIncrementArray[constrainedObjectiveFunctionIndex];
  245.             }
  246.         }

  248.         try
  249.         {
  250.             return new org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier (
  251.                 true,
  252.                 variateIncrementArray,
  253.                 inequalityConstraintIncrementCount
  254.             );
  255.         }
  256.         catch (java.lang.Exception e)
  257.         {
  258.             e.printStackTrace();
  259.         }

  261.         return null;
  262.     }

  264.     /**
  265.      * InteriorFixedPointFinder Constructor
  266.      * 
  267.      * @param rdToR1ObjectiveFunction The Objective Function
  268.      * @param inequalityConstraintMultivariateFunctionArray Array of Inequality Constraints
  269.      * @param lsec The Line Step Evolution Control
  270.      * @param cc Convergence Control Parameters
  271.      * @param barrierStrength Barrier Strength
  272.      * 
  273.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  274.      */

  276.     public InteriorFixedPointFinder (
  277.         final org.drip.function.definition.RdToR1 rdToR1ObjectiveFunction,
  278.         final org.drip.function.definition.RdToR1[] inequalityConstraintMultivariateFunctionArray,
  279.         final org.drip.function.rdtor1descent.LineStepEvolutionControl lsec,
  280.         final org.drip.function.rdtor1solver.ConvergenceControl cc,
  281.         final double barrierStrength)
  282.         throws java.lang.Exception
  283.     {
  284.         super (
  285.             rdToR1ObjectiveFunction,
  286.             lsec,
  287.             cc
  288.         );

  290.         if (null == (_inequalityConstraintMultivariateFunctionArray = inequalityConstraintMultivariateFunctionArray) ||
  291.             !org.drip.numerical.common.NumberUtil.IsValid (_barrierStrength = barrierStrength))
  292.         {
  293.             throw new java.lang.Exception ("InteriorFixedPointFinder Constructor => Invalid Inputs");
  294.         }

  296.         int inequalityConstraintCount = _inequalityConstraintMultivariateFunctionArray.length;
  297.         _boundMultivariateFunctionArray = 0 == inequalityConstraintCount ? null : new
  298.             org.drip.function.rdtor1.BoundMultivariate[inequalityConstraintCount];

  300.         if (0 == inequalityConstraintCount)
  301.         {
  302.             throw new java.lang.Exception ("InteriorFixedPointFinder Constructor => Invalid Inputs");
  303.         }

  305.         for (int inequalityConstraintIndex = 0;
  306.             inequalityConstraintIndex < inequalityConstraintCount;
  307.             ++inequalityConstraintIndex)
  308.         {
  309.             if (null == _inequalityConstraintMultivariateFunctionArray[inequalityConstraintIndex])
  310.             {
  311.                 throw new java.lang.Exception ("InteriorFixedPointFinder Constructor => Invalid Inputs");
  312.             }

  314.             if (_inequalityConstraintMultivariateFunctionArray[inequalityConstraintIndex] instanceof
  315.                 org.drip.function.rdtor1.BoundMultivariate)
  316.             {
  317.                 _boundMultivariateFunctionArray[inequalityConstraintIndex] =
  318.                     (org.drip.function.rdtor1.BoundMultivariate)
  319.                     _inequalityConstraintMultivariateFunctionArray[inequalityConstraintIndex];
  320.             }
  321.         }
  322.     }

  324.     /**
  325.      * Retrieve the Array of Inequality Constraint Function
  326.      * 
  327.      * @return The Array of Inequality Constraint Function
  328.      */

  330.     public org.drip.function.definition.RdToR1[] inequalityConstraintMultivariateFunctionArray()
  331.     {
  332.         return _inequalityConstraintMultivariateFunctionArray;
  333.     }

  335.     /**
  336.      * Retrieve the Barrier Strength
  337.      * 
  338.      * @return The Barrier Strength
  339.      */

  341.     public double barrierStrength()
  342.     {
  343.         return _barrierStrength;
  344.     }

  346.     @Override public org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier increment (
  347.         final org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier currentVariateConstraint)
  348.     {
  349.         if (null == currentVariateConstraint)
  350.         {
  351.             return null;
  352.         }

  354.         double[] variateArray = currentVariateConstraint.variateArray();

  356.         int variateCount = variateArray.length;
  357.         int constraintCount = _inequalityConstraintMultivariateFunctionArray.length;
  358.         double[][] constraintJacobianArray = new double[variateCount][constraintCount];
  359.         double[] constraintValueArray = new double[constraintCount];

  361.         if (0 == constraintCount)
  362.         {
  363.             return null;
  364.         }

  366.         for (int constraintIndex = 0;
  367.             constraintIndex < constraintCount;
  368.             ++constraintIndex)
  369.         {
  370.             try
  371.             {
  372.                 constraintValueArray[constraintIndex] =
  373.                     _inequalityConstraintMultivariateFunctionArray[constraintIndex].evaluate (
  374.                         variateArray
  375.                     );
  376.             }
  377.             catch (java.lang.Exception e)
  378.             {
  379.                 e.printStackTrace();

  381.                 return null;
  382.             }

  384.             double[] constraintJacobian =
  385.                 _inequalityConstraintMultivariateFunctionArray[constraintIndex].jacobian (
  386.                     variateArray
  387.                 );

  389.             if (null == constraintJacobian)
  390.             {
  391.                 return null;
  392.             }

  394.             for (int variateIndex = 0;
  395.                 variateIndex < variateCount;
  396.                 ++variateIndex)
  397.             {
  398.                 constraintJacobianArray[variateIndex][constraintIndex] = constraintJacobian[variateIndex];
  399.             }
  400.         }

  402.         org.drip.function.definition.RdToR1 objectiveFunction = objectiveFunction();

  404.         try
  405.         {
  406.             return incremental (
  407.                 new org.drip.function.rdtor1solver.ObjectiveFunctionPointMetrics (
  408.                     objectiveFunction.jacobian (
  409.                         variateArray
  410.                     ),
  411.                     objectiveFunction.hessian (
  412.                         variateArray
  413.                     )
  414.                 ),
  415.                 new org.drip.function.rdtor1solver.ConstraintFunctionPointMetrics (
  416.                     constraintValueArray,
  417.                     constraintJacobianArray,
  418.                     currentVariateConstraint.constraintMultiplierArray()
  419.                 )
  420.             );
  421.         }
  422.         catch (java.lang.Exception e)
  423.         {
  424.             e.printStackTrace();
  425.         }

  427.         return null;
  428.     }

  430.     @Override public org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier next (
  431.         final org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier currentVariateConstraint,
  432.         final org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier
  433.             incrementalVariateConstraint,
  434.         final double incrementFraction)
  435.     {
  436.         return org.drip.function.rdtor1solver.VariateInequalityConstraintMultiplier.Add (
  437.             currentVariateConstraint,
  438.             incrementalVariateConstraint,
  439.             incrementFraction,
  440.             _boundMultivariateFunctionArray
  441.         );
  442.     }
  443. }
Created with JaCoCo 0.7.9.201702052155