OptimizationFramework.java

  1. package org.drip.optimization.constrained;

  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>OptimizationFramework</i> holds the Non Linear Objective Function and the Collection of Equality and
  82.  * the Inequality Constraints that correspond to the Optimization Setup. The References are:
  83.  * 
  84.  * <br><br>
  85.  *  <ul>
  86.  *      <li>
  87.  *          Boyd, S., and L. van den Berghe (2009): <i>Convex Optimization</i> <b>Cambridge University
  88.  *              Press</b> Cambridge UK
  89.  *      </li>
  90.  *      <li>
  91.  *          Eustaquio, R., E. Karas, and A. Ribeiro (2008): <i>Constraint Qualification for Nonlinear
  92.  *              Programming</i> <b>Federal University of Parana</b>
  93.  *      </li>
  94.  *      <li>
  95.  *          Karush, A. (1939): <i>Minima of Functions of Several Variables with Inequalities as Side
  96.  *          Constraints</i> <b>University of Chicago</b> Chicago IL
  97.  *      </li>
  98.  *      <li>
  99.  *          Kuhn, H. W., and A. W. Tucker (1951): Nonlinear Programming <i>Proceedings of the Second Berkeley
  100.  *              Symposium</i> <b>University of California</b> Berkeley CA 481-492
  101.  *      </li>
  102.  *      <li>
  103.  *          Ruszczynski, A. (2006): <i>Nonlinear Optimization</i> <b>Princeton University Press</b> Princeton
  104.  *              NJ
  105.  *      </li>
  106.  *  </ul>
  107.  *
  108.  *  <br><br>
  109.  *  <ul>
  110.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  111.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalOptimizerLibrary.md">Numerical Optimizer Library</a></li>
  112.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/optimization/README.md">Necessary, Sufficient, and Regularity Checks for Gradient Descent in a Constrained Optimization Setup</a></li>
  113.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/optimization/constrained/README.md">KKT Fritz-John Constrained Optimizer</a></li>
  114.  *  </ul>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class OptimizationFramework {
  120.     private org.drip.function.definition.RdToR1 _rdToR1Objective = null;
  121.     private org.drip.function.definition.RdToR1[] _aRdToR1EqualityConstraint = null;
  122.     private org.drip.function.definition.RdToR1[] _aRdToR1InequalityConstraint = null;

  124.     /**
  125.      * OptimizationFramework Constructor
  126.      * 
  127.      * @param rdToR1Objective The R^d To R^1 Objective Function
  128.      * @param aRdToR1EqualityConstraint The Array of R^d To R^1 Equality Constraint Functions
  129.      * @param aRdToR1InequalityConstraint The Array of R^d To R^1 Inequality Constraint Functions
  130.      * 
  131.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  132.      */

  134.     public OptimizationFramework (
  135.         final org.drip.function.definition.RdToR1 rdToR1Objective,
  136.         final org.drip.function.definition.RdToR1[] aRdToR1EqualityConstraint,
  137.         final org.drip.function.definition.RdToR1[] aRdToR1InequalityConstraint)
  138.         throws java.lang.Exception
  139.     {
  140.         if (null == (_rdToR1Objective = rdToR1Objective))
  141.             throw new java.lang.Exception ("OptimizationFramework Constructor => Invalid Inputs");

  143.         int iObjectiveDimension = _rdToR1Objective.dimension();

  145.         if (null != (_aRdToR1EqualityConstraint = aRdToR1EqualityConstraint)) {
  146.             int iNumEqualityConstraint = _aRdToR1EqualityConstraint.length;

  148.             for (int i = 0; i < iNumEqualityConstraint; ++i) {
  149.                 if (null == _aRdToR1EqualityConstraint[i] || _aRdToR1EqualityConstraint[i].dimension() !=
  150.                     iObjectiveDimension)
  151.                     throw new java.lang.Exception ("OptimizationFramework Constructor => Invalid Inputs");
  152.             }
  153.         }

  155.         if (null != (_aRdToR1InequalityConstraint = aRdToR1InequalityConstraint)) {
  156.             int iNumInequalityConstraint = _aRdToR1InequalityConstraint.length;

  158.             for (int i = 0; i < iNumInequalityConstraint; ++i) {
  159.                 if (null == _aRdToR1InequalityConstraint[i] || _aRdToR1InequalityConstraint[i].dimension() !=
  160.                     iObjectiveDimension)
  161.                     throw new java.lang.Exception ("OptimizationFramework Constructor => Invalid Inputs");
  162.             }
  163.         }
  164.     }

  166.     /**
  167.      * Retrieve the R^d To R^1 Objective Function
  168.      * 
  169.      * @return The R^d To R^1 Objective Function
  170.      */

  172.     public org.drip.function.definition.RdToR1 objectiveFunction()
  173.     {
  174.         return _rdToR1Objective;
  175.     }

  177.     /**
  178.      * Retrieve the Array of R^d To R^1 Equality Constraint Functions
  179.      * 
  180.      * @return The Array of R^d To R^1 Equality Constraint Functions
  181.      */

  183.     public org.drip.function.definition.RdToR1[] equalityConstraint()
  184.     {
  185.         return _aRdToR1EqualityConstraint;
  186.     }

  188.     /**
  189.      * Retrieve the Array of R^d To R^1 Inequality Constraint Functions
  190.      * 
  191.      * @return The Array of R^d To R^1 Inequality Constraint Functions
  192.      */

  194.     public org.drip.function.definition.RdToR1[] inequalityConstraint()
  195.     {
  196.         return _aRdToR1InequalityConstraint;
  197.     }

  199.     /**
  200.      * Retrieve the Number of Equality Constraints
  201.      * 
  202.      * @return The Number of Equality Constraints
  203.      */

  205.     public int numEqualityConstraint()
  206.     {
  207.         return null == _aRdToR1EqualityConstraint ? 0 : _aRdToR1EqualityConstraint.length;
  208.     }

  210.     /**
  211.      * Retrieve the Number of Inequality Constraints
  212.      * 
  213.      * @return The Number of Inequality Constraints
  214.      */

  216.     public int numInequalityConstraint()
  217.     {
  218.         return null == _aRdToR1InequalityConstraint ? 0 : _aRdToR1InequalityConstraint.length;
  219.     }

  221.     /**
  222.      * Indicate if the Optimizer Framework is Lagrangian
  223.      * 
  224.      * @return TRUE - The Optimizer Framework is Lagrangian
  225.      */

  227.     public boolean isLagrangian()
  228.     {
  229.         return 0 == numInequalityConstraint() && 0 != numEqualityConstraint();
  230.     }

  232.     /**
  233.      * Indicate if the Optimizer Framework is Unconstrained
  234.      * 
  235.      * @return TRUE - The Optimizer Framework is Unconstrained
  236.      */

  238.     public boolean isUnconstrained()
  239.     {
  240.         return 0 == numInequalityConstraint() && 0 == numEqualityConstraint();
  241.     }

  243.     /**
  244.      * Indicate if the specified Fritz John Multipliers are compatible with the Optimization Framework
  245.      * 
  246.      * @param fjm The specified FJM Multipliers
  247.      * 
  248.      * @return TRUE - The specified Fritz John Multipliers are compatible with the Optimization Framework
  249.      */

  251.     public boolean isCompatible (
  252.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm)
  253.     {
  254.         int iNumEqualityConstraint = numEqualityConstraint();

  256.         int iNumInequalityConstraint = numInequalityConstraint();

  258.         int iNumEqualityFJMMultiplier = null == fjm ? 0 : fjm.numEqualityCoefficients();

  260.         if (iNumEqualityConstraint != iNumEqualityFJMMultiplier) return false;

  262.         int iNumInequalityFJMMultiplier = null == fjm ? 0 : fjm.numInequalityCoefficients();

  264.         return iNumInequalityConstraint == iNumInequalityFJMMultiplier;
  265.     }

  267.     /**
  268.      * Check the Candidate Point for Primal Feasibility
  269.      * 
  270.      * @param adblVariate The Candidate R^d Variate
  271.      * 
  272.      * @return TRUE - The Candidate Point has passed the Primal Feasibility Test
  273.      * 
  274.      * @throws java.lang.Exception Thrown if the Input in Invalid
  275.      */

  277.     public boolean primalFeasibilityCheck (
  278.         final double[] adblVariate)
  279.         throws java.lang.Exception
  280.     {
  281.         int iNumEqualityConstraint = numEqualityConstraint();

  283.         int iNumInequalityConstraint = numInequalityConstraint();

  285.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  286.             if (0. != _aRdToR1EqualityConstraint[i].evaluate (adblVariate)) return false;
  287.         }

  289.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  290.             if (0. < _aRdToR1InequalityConstraint[i].evaluate (adblVariate)) return false;
  291.         }

  293.         return true;
  294.     }

  296.     /**
  297.      * Check for Complementary Slackness across the Inequality Constraints
  298.      * 
  299.      * @param fjm The specified Fritz John Multipliers
  300.      * @param adblVariate The Candidate R^d Variate
  301.      * 
  302.      * @return TRUE - The Complementary Slackness Test passed
  303.      * 
  304.      * @throws java.lang.Exception Thrown if the Input in Invalid
  305.      */

  307.     public boolean complementarySlacknessCheck (
  308.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  309.         final double[] adblVariate)
  310.         throws java.lang.Exception
  311.     {
  312.         if (!isCompatible (fjm))
  313.             throw new java.lang.Exception
  314.                 ("OptimizationFramework::complementarySlacknessCheck => Invalid Inputs");

  316.         int iNumInequalityConstraint = numInequalityConstraint();

  318.         double[] adblInequalityConstraintCoefficient = null == fjm ? null :
  319.             fjm.inequalityConstraintCoefficient();

  321.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  322.             if (0. != _aRdToR1InequalityConstraint[i].evaluate (adblVariate) *
  323.                 adblInequalityConstraintCoefficient[i])
  324.                 return false;
  325.         }

  327.         return true;
  328.     }

  330.     /**
  331.      * Check the Candidate Point for First Order Necessary Condition
  332.      * 
  333.      * @param fjm The specified Fritz John Multipliers
  334.      * @param adblVariate The Candidate R^d Variate
  335.      * 
  336.      * @return TRUE - The Candidate Point satisfied the First Order Necessary Condition
  337.      * 
  338.      * @throws java.lang.Exception Thrown if the Input in Invalid
  339.      */

  341.     public boolean isFONC (
  342.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  343.         final double[] adblVariate)
  344.         throws java.lang.Exception
  345.     {
  346.         if (!isCompatible (fjm))
  347.             throw new java.lang.Exception ("OptimizationFramework::isFONC => Invalid Inputs");

  349.         double[] adblFONCJacobian = _rdToR1Objective.jacobian (adblVariate);

  351.         if (null == adblFONCJacobian)
  352.             throw new java.lang.Exception ("OptimizationFramework::isFONC => Cannot calculate Jacobian");

  354.         int iNumEqualityConstraint = numEqualityConstraint();

  356.         int iNumInequalityConstraint = numInequalityConstraint();

  358.         double[] adblEqualityConstraintCoefficient = null == fjm ? null :
  359.             fjm.equalityConstraintCoefficient();

  361.         double[] adblInequalityConstraintCoefficient = null == fjm ? null :
  362.             fjm.inequalityConstraintCoefficient();

  364.         int iDimension = _rdToR1Objective.dimension();

  366.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  367.             double[] adblJacobian = _aRdToR1EqualityConstraint[i].jacobian (adblVariate);

  369.             if (null == adblJacobian)
  370.                 throw new java.lang.Exception ("OptimizationFramework::isFONC => Cannot calculate Jacobian");

  372.             for (int j = 0; j < iDimension; ++j)
  373.                 adblFONCJacobian[j] = adblFONCJacobian[j] + adblEqualityConstraintCoefficient[j] *
  374.                     adblJacobian[j];
  375.         }

  377.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  378.             double[] adblJacobian = _aRdToR1InequalityConstraint[i].jacobian (adblVariate);

  380.             if (null == adblJacobian)
  381.                 throw new java.lang.Exception ("OptimizationFramework::isFONC => Cannot calculate Jacobian");

  383.             for (int j = 0; j < iDimension; ++j)
  384.                 adblFONCJacobian[j] = adblFONCJacobian[j] + adblInequalityConstraintCoefficient[j] *
  385.                     adblJacobian[j];
  386.         }

  388.         for (int j = 0; j < iDimension; ++j) {
  389.             if (0. != adblFONCJacobian[j]) return false;
  390.         }

  392.         return true;
  393.     }

  395.     /**
  396.      * Check the Candidate Point for Second Order Sufficiency Condition
  397.      * 
  398.      * @param fjm The specified Fritz John Multipliers
  399.      * @param adblVariate The Candidate R^d Variate
  400.      * @param bCheckForMinima TRUE - Check whether the R^d Variate corresponds to the SOSC Minimum
  401.      * 
  402.      * @return TRUE - The Candidate Point satisfies the Second Order Sufficiency Condition
  403.      * 
  404.      * @throws java.lang.Exception Thrown if the Input in Invalid
  405.      */

  407.     public boolean isSOSC (
  408.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  409.         final double[] adblVariate,
  410.         final boolean bCheckForMinima)
  411.         throws java.lang.Exception
  412.     {
  413.         if (!isFONC (fjm, adblVariate)) return false;

  415.         double[][] aadblSOSCHessian = _rdToR1Objective.hessian (adblVariate);

  417.         if (null == aadblSOSCHessian)
  418.             throw new java.lang.Exception ("OptimizationFramework::isSOSC => Cannot calculate Jacobian");

  420.         int iNumEqualityConstraint = numEqualityConstraint();

  422.         int iNumInequalityConstraint = numInequalityConstraint();

  424.         double[] adblEqualityConstraintCoefficient = null == fjm ? null :
  425.             fjm.equalityConstraintCoefficient();

  427.         double[] adblInequalityConstraintCoefficient = null == fjm ? null :
  428.             fjm.inequalityConstraintCoefficient();

  430.         int iDimension = _rdToR1Objective.dimension();

  432.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  433.             double[][] aadblHessian = _aRdToR1EqualityConstraint[i].hessian (adblVariate);

  435.             if (null == aadblHessian)
  436.                 throw new java.lang.Exception ("OptimizationFramework::isSOSC => Cannot calculate Jacobian");

  438.             for (int j = 0; j < iDimension; ++j) {
  439.                 for (int k = 0; k < iDimension; ++k)
  440.                     aadblSOSCHessian[j][k] = aadblSOSCHessian[j][k] + adblEqualityConstraintCoefficient[j] *
  441.                         aadblHessian[j][k];
  442.             }
  443.         }

  445.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  446.             double[][] aadblHessian = _aRdToR1InequalityConstraint[i].hessian (adblVariate);

  448.             if (null == aadblHessian)
  449.                 throw new java.lang.Exception ("OptimizationFramework::isSOSC => Cannot calculate Jacobian");

  451.             for (int j = 0; j < iDimension; ++j) {
  452.                 for (int k = 0; k < iDimension; ++k)
  453.                     aadblSOSCHessian[j][k] = aadblSOSCHessian[j][k] + adblInequalityConstraintCoefficient[j]
  454.                         * aadblHessian[j][k];
  455.             }
  456.         }

  458.         double dblSOSC = org.drip.numerical.linearalgebra.Matrix.DotProduct (adblVariate,
  459.             org.drip.numerical.linearalgebra.Matrix.Product (aadblSOSCHessian, adblVariate));

  461.         return (bCheckForMinima && dblSOSC > 0.) || (!bCheckForMinima && dblSOSC < 0.);
  462.     }

  464.     /**
  465.      * Generate the Battery of Necessary and Sufficient Qualification Tests
  466.      * 
  467.      * @param fjm The specified Fritz John Multipliers
  468.      * @param adblVariate The Candidate R^d Variate
  469.      * @param bCheckForMinima TRUE - Check whether the R^d Variate corresponds to the SOSC Minimum
  470.      * 
  471.      * @return The Necessary and Sufficient Conditions Qualifier Instance
  472.      */

  474.     public org.drip.optimization.constrained.NecessarySufficientConditions necessarySufficientQualifier (
  475.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  476.         final double[] adblVariate,
  477.         final boolean bCheckForMinima)
  478.     {
  479.         try {
  480.             return org.drip.optimization.constrained.NecessarySufficientConditions.Standard (adblVariate, fjm,
  481.                 bCheckForMinima, primalFeasibilityCheck (adblVariate), fjm.dualFeasibilityCheck(),
  482.                     complementarySlacknessCheck (fjm, adblVariate), isFONC (fjm, adblVariate), isSOSC (fjm,
  483.                         adblVariate, bCheckForMinima));
  484.         } catch (java.lang.Exception e) {
  485.             e.printStackTrace();
  486.         }

  488.         return null;
  489.     }

  491.     /**
  492.      * Retrieve the Array of Active Constraints
  493.      * 
  494.      * @param adblVariate The R^d Variate
  495.      * 
  496.      * @return The Array of Active Constraints
  497.      */

  499.     public org.drip.function.definition.RdToR1[] activeConstraints (
  500.         final double[] adblVariate)
  501.     {
  502.         int iNumEqualityConstraint = numEqualityConstraint();

  504.         int iNumInequalityConstraint = numInequalityConstraint();

  506.         java.util.List<org.drip.function.definition.RdToR1> lsActiveConstraint = new
  507.             java.util.ArrayList<org.drip.function.definition.RdToR1>();

  509.         for (int i = 0; i < iNumEqualityConstraint; ++i)
  510.             lsActiveConstraint.add (_aRdToR1EqualityConstraint[i]);

  512.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  513.             try {
  514.                 if (0. == _aRdToR1InequalityConstraint[i].evaluate (adblVariate))
  515.                     lsActiveConstraint.add (_aRdToR1InequalityConstraint[i]);
  516.             } catch (java.lang.Exception e) {
  517.                 e.printStackTrace();

  519.                 return null;
  520.             }
  521.         }

  523.         int iNumActiveConstraint = lsActiveConstraint.size();

  525.         org.drip.function.definition.RdToR1[] aRdToR1ActiveConstraint = new
  526.             org.drip.function.definition.RdToR1[iNumActiveConstraint];

  528.         for (int i = 0; i < iNumActiveConstraint; ++i)
  529.             aRdToR1ActiveConstraint[i] = lsActiveConstraint.get (i);

  531.         return aRdToR1ActiveConstraint;
  532.     }

  534.     /**
  535.      * Active Constraint Set Rank Computation
  536.      * 
  537.      * @param adblVariate The Candidate R^d Variate
  538.      * 
  539.      * @return The Active Constraint Set Rank
  540.      * 
  541.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  542.      */

  544.     public int activeConstraintRank (
  545.         final double[] adblVariate)
  546.         throws java.lang.Exception
  547.     {
  548.         int iNumEqualityConstraint = numEqualityConstraint();

  550.         int iNumInequalityConstraint = numInequalityConstraint();

  552.         java.util.List<double[]> lsJacobian = new java.util.ArrayList<double[]>();

  554.         double[] adblJacobian = _rdToR1Objective.jacobian (adblVariate);

  556.         if (null == adblJacobian)
  557.             throw new java.lang.Exception ("OptimizationFramework::activeConstraintRank => Cannot Compute");

  559.         lsJacobian.add (adblJacobian);

  561.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  562.             if (null == (adblJacobian = _aRdToR1EqualityConstraint[i].jacobian (adblVariate)))
  563.                 throw new java.lang.Exception
  564.                     ("OptimizationFramework::activeConstraintRank => Cannot Compute");

  566.             lsJacobian.add (adblJacobian);
  567.         }

  569.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  570.             if (0. == _aRdToR1InequalityConstraint[i].evaluate (adblVariate)) {
  571.                 if (null == (adblJacobian = _aRdToR1InequalityConstraint[i].jacobian (adblVariate)))
  572.                     throw new java.lang.Exception
  573.                         ("OptimizationFramework::activeConstraintRank => Cannot Compute");

  575.                 lsJacobian.add (adblJacobian);
  576.             }
  577.         }

  579.         int iNumJacobian = lsJacobian.size();

  581.         double[][] aadblJacobian = new double[iNumJacobian][];

  583.         for (int i = 0; i < iNumJacobian; ++i)
  584.             aadblJacobian[i] = lsJacobian.get (i);

  586.         return org.drip.numerical.linearalgebra.Matrix.Rank (aadblJacobian);
  587.     }

  589.     /**
  590.      * Compare the Active Constraint Set Rank at the specified against the specified Rank
  591.      * 
  592.      * @param adblVariate The Candidate R^d Variate
  593.      * @param iRank The specified Rank
  594.      * 
  595.      * @return TRUE - Active Constraint Set Rank matches the specified Rank
  596.      * 
  597.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  598.      */

  600.     public boolean activeConstraintRankComparison (
  601.         final double[] adblVariate,
  602.         final int iRank)
  603.         throws java.lang.Exception
  604.     {
  605.         return activeConstraintRank (adblVariate) == iRank;
  606.     }

  608.     /**
  609.      * Active Constraint Set Linear Dependence Check
  610.      * 
  611.      * @param adblVariate The Candidate R^d Variate
  612.      * @param bPositiveLinearDependenceCheck TRUE - Perform an Additional Positive Dependence Check
  613.      * 
  614.      * @return TRUE - Active Constraint Set Linear Dependence Check is satisfied
  615.      * 
  616.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  617.      */

  619.     public boolean activeConstraintLinearDependence (
  620.         final double[] adblVariate,
  621.         final boolean bPositiveLinearDependenceCheck)
  622.         throws java.lang.Exception
  623.     {
  624.         int iNumEqualityConstraint = numEqualityConstraint();

  626.         int iNumInequalityConstraint = numInequalityConstraint();

  628.         int iNumConstraint = iNumEqualityConstraint + iNumInequalityConstraint;
  629.         double[][] aadblJacobian = new double[iNumConstraint][];

  631.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  632.             if (null == (aadblJacobian[i] = _aRdToR1EqualityConstraint[i].jacobian (adblVariate)))
  633.                 return false;
  634.         }

  636.         for (int i = iNumEqualityConstraint; i < iNumConstraint; ++i) {
  637.             aadblJacobian[i] = null;
  638.             org.drip.function.definition.RdToR1 rdToR1InequalityConstraint =
  639.                 _aRdToR1InequalityConstraint[i - iNumEqualityConstraint];

  641.             if (0. == rdToR1InequalityConstraint.evaluate (adblVariate)) {
  642.                 if (null == (aadblJacobian[i] = rdToR1InequalityConstraint.jacobian (adblVariate)))
  643.                     return false;
  644.             }
  645.         }

  647.         for (int i = 0; i < iNumConstraint; ++i) {
  648.             if (null != aadblJacobian[i]) {
  649.                 for (int j = i + 1; j < iNumConstraint; ++j) {
  650.                     if (null != aadblJacobian[j] && 0. != org.drip.numerical.linearalgebra.Matrix.DotProduct
  651.                         (aadblJacobian[i], aadblJacobian[j]))
  652.                         return false;
  653.                 }
  654.             }
  655.         }

  657.         if (bPositiveLinearDependenceCheck) {
  658.             for (int i = 0; i < iNumConstraint; ++i) {
  659.                 if (null != aadblJacobian[i] &&
  660.                     !org.drip.numerical.linearalgebra.Matrix.PositiveLinearlyIndependent (aadblJacobian[i]))
  661.                     return false;
  662.             }
  663.         }

  665.         return true;
  666.     }

  668.     /**
  669.      * Compute the Along/Away "Naturally" Incremented Variates
  670.      * 
  671.      * @param adblVariate The Candidate R^d Variate
  672.      * 
  673.      * @return The Along/Away "Natural" Incremented Variates
  674.      */

  676.     public double[][] alongAwayVariate (
  677.         final double[] adblVariate)
  678.     {
  679.         double[] adblVariateIncrement = org.drip.numerical.linearalgebra.Matrix.Product
  680.             (org.drip.numerical.linearalgebra.Matrix.InvertUsingGaussianElimination (_rdToR1Objective.hessian
  681.                 (adblVariate)), _rdToR1Objective.jacobian (adblVariate));

  683.         if (null == adblVariateIncrement) return null;

  685.         int iVariateDimension = adblVariate.length;
  686.         double[] adblVariateAway = new double[iVariateDimension];
  687.         double[] adblVariateAlong = new double[iVariateDimension];

  689.         for (int i = 0; i < iVariateDimension; ++i) {
  690.             adblVariateAway[i] = adblVariate[i] - adblVariateIncrement[i];
  691.             adblVariateAlong[i] = adblVariate[i] + adblVariateIncrement[i];
  692.         }

  694.         return new double[][] {adblVariateAlong, adblVariateAway};
  695.     }

  697.     /**
  698.      * Check for Linearity Constraint Qualification
  699.      * 
  700.      * @return TRUE - Linearity Constraint Qualification is satisfied
  701.      */

  703.     public boolean isLCQ()
  704.     {
  705.         int iNumEqualityConstraint = numEqualityConstraint();

  707.         int iNumInequalityConstraint = numInequalityConstraint();

  709.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  710.             if (!(_aRdToR1EqualityConstraint[i] instanceof org.drip.function.rdtor1.AffineMultivariate))
  711.                 return false;
  712.         }

  714.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  715.             if (!(_aRdToR1InequalityConstraint[i] instanceof org.drip.function.rdtor1.AffineMultivariate))
  716.                 return false;
  717.         }

  719.         return true;
  720.     }

  722.     /**
  723.      * Check for Linearity Independent Constraint Qualification
  724.      * 
  725.      * @param adblVariate The Candidate R^d Variate
  726.      * 
  727.      * @return TRUE - Linearity Independent Constraint Qualification is satisfied
  728.      * 
  729.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  730.      */

  732.     public boolean isLICQ (
  733.         final double[] adblVariate)
  734.         throws java.lang.Exception
  735.     {
  736.         return activeConstraintLinearDependence (adblVariate, false);
  737.     }

  739.     /**
  740.      * Check for Mangasarian Fromovitz Constraint Qualification
  741.      * 
  742.      * @param adblVariate The Candidate R^d Variate
  743.      * 
  744.      * @return TRUE - The Mangasarian Fromovitz Constraint Qualification is satisfied
  745.      * 
  746.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  747.      */

  749.     public boolean isMFCQ (
  750.         final double[] adblVariate)
  751.         throws java.lang.Exception
  752.     {
  753.         return activeConstraintLinearDependence (adblVariate, true);
  754.     }

  756.     /**
  757.      * Check for Constant Rank Constraint Qualification
  758.      * 
  759.      * @param adblVariate The Candidate R^d Variate
  760.      * 
  761.      * @return TRUE - The Constant Rank Constraint Qualification is satisfied
  762.      * 
  763.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  764.      */

  766.     public boolean isCRCQ (
  767.         final double[] adblVariate)
  768.         throws java.lang.Exception
  769.     {
  770.         int iRank = activeConstraintRank (adblVariate);

  772.         double[][] aadblAlongAwayVariatePair = alongAwayVariate (adblVariate);

  774.         if (null == aadblAlongAwayVariatePair)
  775.             throw new java.lang.Exception ("OptimizationFramework::isCRCQ => Cannot generate along/away");

  777.         return iRank == activeConstraintRank (aadblAlongAwayVariatePair[0]) && iRank == activeConstraintRank
  778.             (aadblAlongAwayVariatePair[1]);
  779.     }

  781.     /**
  782.      * Check for Constant Positive Linear Dependence Constraint Qualification
  783.      * 
  784.      * @param adblVariate The Candidate R^d Variate
  785.      * 
  786.      * @return TRUE - The Constant Positive Linear Dependence Constraint Qualification is satisfied
  787.      * 
  788.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  789.      */

  791.     public boolean isCPLDCQ (
  792.         final double[] adblVariate)
  793.         throws java.lang.Exception
  794.     {
  795.         if (!isMFCQ (adblVariate)) return false;

  797.         double[][] aadblAlongAwayVariatePair = alongAwayVariate (adblVariate);

  799.         if (null == aadblAlongAwayVariatePair)
  800.             throw new java.lang.Exception ("OptimizationFramework::isCPLDCQ => Cannot generate along/away");

  802.         return isMFCQ (aadblAlongAwayVariatePair[0]) && isMFCQ (aadblAlongAwayVariatePair[1]);
  803.     }

  805.     /**
  806.      * Check for Quasi Normal Constraint Qualification
  807.      * 
  808.      * @param fjm The specified Fritz John Multipliers
  809.      * @param adblVariate The Candidate R^d Variate
  810.      * 
  811.      * @return TRUE - The Quasi Normal Constraint Qualification is satisfied
  812.      * 
  813.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  814.      */

  816.     public boolean isQNCQ (
  817.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  818.         final double[] adblVariate)
  819.         throws java.lang.Exception
  820.     {
  821.         if (!isCompatible (fjm))
  822.             throw new java.lang.Exception ("OptimizationFramework::isQNCQ => Invalid Inputs");

  824.         if (!isMFCQ (adblVariate)) return false;

  826.         int iNumEqualityConstraint = numEqualityConstraint();

  828.         double[] adblEqualityConstraintCoefficient = null == fjm ? null :
  829.             fjm.equalityConstraintCoefficient();

  831.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  832.             if (0. != adblEqualityConstraintCoefficient[i] && 0. <= _aRdToR1EqualityConstraint[i].evaluate
  833.                 (adblVariate) * adblEqualityConstraintCoefficient[i])
  834.                 return false;
  835.         }

  837.         int iNumInequalityConstraint = numInequalityConstraint();

  839.         double[] adblInequalityConstraintCoefficient = null == fjm ? null :
  840.             fjm.inequalityConstraintCoefficient();

  842.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  843.             if (0. != adblInequalityConstraintCoefficient[i] && 0. <=
  844.                 _aRdToR1InequalityConstraint[i].evaluate (adblVariate) *
  845.                     adblInequalityConstraintCoefficient[i])
  846.                 return false;
  847.         }

  849.         return true;
  850.     }

  852.     /**
  853.      * Check for Slater Condition Constraint Qualification
  854.      * 
  855.      * @param adblVariate The Candidate R^d Variate
  856.      * 
  857.      * @return TRUE - The Slater Condition Constraint Qualification is satisfied
  858.      * 
  859.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  860.      */

  862.     public boolean isSCCQ (
  863.         final double[] adblVariate)
  864.         throws java.lang.Exception
  865.     {
  866.         if (!(_rdToR1Objective instanceof org.drip.function.rdtor1.ConvexMultivariate)) return false;

  868.         int iNumEqualityConstraint = numEqualityConstraint();

  870.         int iNumInequalityConstraint = numInequalityConstraint();

  872.         for (int i = 0; i < iNumEqualityConstraint; ++i) {
  873.             if (0. != _aRdToR1EqualityConstraint[i].evaluate (adblVariate)) return false;
  874.         }

  876.         for (int i = 0; i < iNumInequalityConstraint; ++i) {
  877.             if (0. <= _aRdToR1InequalityConstraint[i].evaluate (adblVariate)) return false;
  878.         }

  880.         return true;
  881.     }

  883.     /**
  884.      * Generate the Battery of Regularity Constraint Qualification Tests
  885.      * 
  886.      * @param fjm The specified Fritz John Multipliers
  887.      * @param adblVariate The Candidate R^d Variate
  888.      * 
  889.      * @return The Regularity Constraint Qualifier Instance
  890.      */

  892.     public org.drip.optimization.constrained.RegularityConditions regularityQualifier (
  893.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  894.         final double[] adblVariate)
  895.     {
  896.         try {
  897.             return org.drip.optimization.constrained.RegularityConditions.Standard (adblVariate, fjm,
  898.                 isLCQ(), isLICQ (adblVariate), isMFCQ (adblVariate), isCRCQ (adblVariate), isCPLDCQ
  899.                     (adblVariate), isQNCQ (fjm, adblVariate), isSCCQ (adblVariate));
  900.         } catch (java.lang.Exception e) {
  901.             e.printStackTrace();
  902.         }

  904.         return null;
  905.     }
  906. }
Created with JaCoCo 0.7.9.201702052155