RegularityConditions.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>RegularityConditions</i> holds the Results of the Verification of the Regularity Conditions/Constraint
  82.  * Qualifications at the specified (possibly) Optimal Variate and the corresponding Fritz John Multipliers.
  83.  * The References are:
  84.  * 
  85.  * <br><br>
  86.  *  <ul>
  87.  *      <li>
  88.  *          Boyd, S., and L. van den Berghe (2009): <i>Convex Optimization</i> <b>Cambridge University
  89.  *              Press</b> Cambridge UK
  90.  *      </li>
  91.  *      <li>
  92.  *          Eustaquio, R., E. Karas, and A. Ribeiro (2008): <i>Constraint Qualification for Nonlinear
  93.  *              Programming</i> <b>Federal University of Parana</b>
  94.  *      </li>
  95.  *      <li>
  96.  *          Karush, A. (1939): <i>Minima of Functions of Several Variables with Inequalities as Side
  97.  *          Constraints</i> <b>University of Chicago</b> Chicago IL
  98.  *      </li>
  99.  *      <li>
  100.  *          Kuhn, H. W., and A. W. Tucker (1951): Nonlinear Programming <i>Proceedings of the Second Berkeley
  101.  *              Symposium</i> <b>University of California</b> Berkeley CA 481-492
  102.  *      </li>
  103.  *      <li>
  104.  *          Ruszczynski, A. (2006): <i>Nonlinear Optimization</i> <b>Princeton University Press</b> Princeton
  105.  *              NJ
  106.  *      </li>
  107.  *  </ul>
  108.  *
  109.  *  <br><br>
  110.  *  <ul>
  111.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  112.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalOptimizerLibrary.md">Numerical Optimizer Library</a></li>
  113.  *      <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>
  114.  *      <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>
  115.  *  </ul>
  116.  * 
  117.  * @author Lakshmi Krishnamurthy
  118.  */

  120. public class RegularityConditions {
  121.     private double[] _adblVariate = null;
  122.     private org.drip.optimization.constrained.FritzJohnMultipliers _fjm = null;
  123.     private org.drip.optimization.regularity.ConstraintQualifierLCQ _cqLCQ = null;
  124.     private org.drip.optimization.regularity.ConstraintQualifierCRCQ _cqCRCQ = null;
  125.     private org.drip.optimization.regularity.ConstraintQualifierLICQ _cqLICQ = null;
  126.     private org.drip.optimization.regularity.ConstraintQualifierMFCQ _cqMFCQ = null;
  127.     private org.drip.optimization.regularity.ConstraintQualifierQNCQ _cqQNCQ = null;
  128.     private org.drip.optimization.regularity.ConstraintQualifierSCCQ _cqSCCQ = null;
  129.     private org.drip.optimization.regularity.ConstraintQualifierCPLDCQ _cqCPLDCQ = null;

  131.     /**
  132.      * Construct a Standard Instance of RegularityConditions
  133.      * 
  134.      * @param adblVariate The Candidate Variate Array
  135.      * @param fjm The Fritz John Multipliers
  136.      * @param bValidLCQ The LCQ Validity Flag
  137.      * @param bValidLICQ The LICQ Validity Flag
  138.      * @param bValidMFCQ The MFCQ Validity Flag
  139.      * @param bValidCRCQ The CRCQ Validity Flag
  140.      * @param bValidCPLDCQ The CPLDCQ Validity Flag
  141.      * @param bValidQNCQ The QNCQ Validity Flag
  142.      * @param bValidSCCQ The SCCQ Validity Flag
  143.      * 
  144.      * @return The Standard Instance of CandidateRegularity
  145.      */

  147.     public static final RegularityConditions Standard (
  148.         final double[] adblVariate,
  149.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  150.         final boolean bValidLCQ,
  151.         final boolean bValidLICQ,
  152.         final boolean bValidMFCQ,
  153.         final boolean bValidCRCQ,
  154.         final boolean bValidCPLDCQ,
  155.         final boolean bValidQNCQ,
  156.         final boolean bValidSCCQ)
  157.     {
  158.         try {
  159.             return new RegularityConditions (adblVariate, fjm, new
  160.                 org.drip.optimization.regularity.ConstraintQualifierLCQ (bValidLCQ), new
  161.                     org.drip.optimization.regularity.ConstraintQualifierLICQ (bValidLICQ), new
  162.                         org.drip.optimization.regularity.ConstraintQualifierMFCQ (bValidMFCQ), new
  163.                             org.drip.optimization.regularity.ConstraintQualifierCRCQ (bValidCRCQ), new
  164.                                 org.drip.optimization.regularity.ConstraintQualifierCPLDCQ (bValidCPLDCQ),
  165.                                     new org.drip.optimization.regularity.ConstraintQualifierQNCQ
  166.                                         (bValidQNCQ), new
  167.                                             org.drip.optimization.regularity.ConstraintQualifierSCCQ
  168.                                                 (bValidSCCQ));
  169.         } catch (java.lang.Exception e) {
  170.             e.printStackTrace();
  171.         }

  173.         return null;
  174.     }

  176.     /**
  177.      * RegularityConditions Constructor
  178.      * 
  179.      * @param adblVariate The Candidate Variate Array
  180.      * @param fjm The Fritz John Multipliers
  181.      * @param cqLCQ LCQ Constraint Qualifier Instance
  182.      * @param cqLICQ LICQ Constraint Qualifier Instance
  183.      * @param cqMFCQ MFCQ Constraint Qualifier Instance
  184.      * @param cqCRCQ CRCQ Constraint Qualifier Instance
  185.      * @param cqCPLDCQ CPLDCQ Constraint Qualifier Instance
  186.      * @param cqQNCQ QNCQ Constraint Qualifier Instance
  187.      * @param cqSCCQ SCCQ Constraint Qualifier Instance
  188.      * 
  189.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  190.      */

  192.     public RegularityConditions (
  193.         final double[] adblVariate,
  194.         final org.drip.optimization.constrained.FritzJohnMultipliers fjm,
  195.         final org.drip.optimization.regularity.ConstraintQualifierLCQ cqLCQ,
  196.         final org.drip.optimization.regularity.ConstraintQualifierLICQ cqLICQ,
  197.         final org.drip.optimization.regularity.ConstraintQualifierMFCQ cqMFCQ,
  198.         final org.drip.optimization.regularity.ConstraintQualifierCRCQ cqCRCQ,
  199.         final org.drip.optimization.regularity.ConstraintQualifierCPLDCQ cqCPLDCQ,
  200.         final org.drip.optimization.regularity.ConstraintQualifierQNCQ cqQNCQ,
  201.         final org.drip.optimization.regularity.ConstraintQualifierSCCQ cqSCCQ)
  202.         throws java.lang.Exception
  203.     {
  204.         if (null == (_adblVariate = adblVariate) || 0 == _adblVariate.length || null == (_fjm = fjm) || null
  205.             == (_cqLCQ = cqLCQ) || null == (_cqLICQ = cqLICQ) || null == (_cqMFCQ = cqMFCQ) || null ==
  206.                 (_cqCRCQ = cqCRCQ) || null == (_cqCPLDCQ = cqCPLDCQ) || null == (_cqQNCQ = cqQNCQ) || null ==
  207.                     (_cqSCCQ = cqSCCQ))
  208.             throw new java.lang.Exception ("RegularityConditions Constructor => Invalid Inputs");
  209.     }

  211.     /**
  212.      * Retrieve the Candidate Variate Array
  213.      * 
  214.      * @return The Candidate Variate Array
  215.      */

  217.     public double[] variate()
  218.     {
  219.         return _adblVariate;
  220.     }

  222.     /**
  223.      * Retrieve the Fritz John Mutipliers
  224.      * 
  225.      * @return The Fritz John Mutipliers
  226.      */

  228.     public org.drip.optimization.constrained.FritzJohnMultipliers fjm()
  229.     {
  230.         return _fjm;
  231.     }

  233.     /**
  234.      * Retrieve the LCQ Constraint Qualifier
  235.      * 
  236.      * @return The LCQ Constraint Qualifier
  237.      */

  239.     public org.drip.optimization.regularity.ConstraintQualifierLCQ lcq()
  240.     {
  241.         return _cqLCQ;
  242.     }

  244.     /**
  245.      * Retrieve the LICQ Constraint Qualifier
  246.      * 
  247.      * @return The LICQ Constraint Qualifier
  248.      */

  250.     public org.drip.optimization.regularity.ConstraintQualifierLICQ licq()
  251.     {
  252.         return _cqLICQ;
  253.     }

  255.     /**
  256.      * Retrieve the MFCQ Constraint Qualifier
  257.      * 
  258.      * @return The MFCQ Constraint Qualifier
  259.      */

  261.     public org.drip.optimization.regularity.ConstraintQualifierMFCQ mfcq()
  262.     {
  263.         return _cqMFCQ;
  264.     }

  266.     /**
  267.      * Retrieve the CRCQ Constraint Qualifier
  268.      * 
  269.      * @return The CRCQ Constraint Qualifier
  270.      */

  272.     public org.drip.optimization.regularity.ConstraintQualifierCRCQ crcq()
  273.     {
  274.         return _cqCRCQ;
  275.     }

  277.     /**
  278.      * Retrieve the CPLDCQ Constraint Qualifier
  279.      * 
  280.      * @return The CPLDCQ Constraint Qualifier
  281.      */

  283.     public org.drip.optimization.regularity.ConstraintQualifierCPLDCQ cpldcq()
  284.     {
  285.         return _cqCPLDCQ;
  286.     }

  288.     /**
  289.      * Retrieve the QNCQ Constraint Qualifier
  290.      * 
  291.      * @return The QNCQ Constraint Qualifier
  292.      */

  294.     public org.drip.optimization.regularity.ConstraintQualifierQNCQ qncq()
  295.     {
  296.         return _cqQNCQ;
  297.     }

  299.     /**
  300.      * Retrieve the SCCQ Constraint Qualifier
  301.      * 
  302.      * @return The SCCQ Constraint Qualifier
  303.      */

  305.     public org.drip.optimization.regularity.ConstraintQualifierSCCQ sccq()
  306.     {
  307.         return _cqSCCQ;
  308.     }

  310.     /**
  311.      * Indicate the Ordered Gross Regularity Validity across all the Constraint Qualifiers
  312.      * 
  313.      * @return TRUE - The Ordered Regularity Criteria is satisfied across all the Constraint Qualifiers
  314.      */

  316.     public boolean valid()
  317.     {
  318.         return _cqLICQ.valid() && _cqCRCQ.valid() && _cqMFCQ.valid() && _cqCPLDCQ.valid() && _cqQNCQ.valid();
  319.     }

  321.     /**
  322.      * Retrieve the Array of Strength Orders as specified in Eustaquio, Karas, and Ribeiro (2008)
  323.      * 
  324.      * @return The Array of Strength Orders as specified in Eustaquio, Karas, and Ribeiro (2008)
  325.      */

  327.     public java.lang.String[] strengthOrder()
  328.     {
  329.         return new java.lang.String[] {"EUSTAQUIO KARAS RIBEIRO STRENGTH ORDER #1: " + _cqLICQ.display() +
  330.             " >> " + _cqMFCQ.display() + " >> " + _cqCPLDCQ.display() + " >> " + _cqQNCQ.display(),
  331.                 "EUSTAQUIO KARAS RIBEIRO STRENGTH ORDER #2: " + _cqLICQ.display() + " >> " +
  332.                     _cqCRCQ.display() + " >> " + _cqCPLDCQ.display() + " >> " + _cqQNCQ.display(),
  333.                         "EUSTAQUIO KARAS RIBEIRO STRENGTH ORDER #3: " + _cqLCQ.display() + " >> " +
  334.                             _cqLICQ.display() + " >> " + _cqMFCQ.display() + " >> " + _cqCRCQ.display() +
  335.                                 " >> " + _cqCPLDCQ.display() + " >> " + _cqQNCQ.display() + " >> " + " >> " +
  336.                                     _cqSCCQ.display()};
  337.     }
  338. }
Created with JaCoCo 0.7.9.201702052155