NormedRxToNormedR1Finite.java

  1. package org.drip.spaces.functionclass;

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

  81. /**
  82.  * <i>NormedRxToNormedR1Finite</i> implements the Class F with f E f : Normed R<sup>x</sup> To Normed
  83.  * R<sup>1</sup> Space of Finite Functions. The Reference we've used is:
  84.  *
  85.  * <br><br>
  86.  *  <ul>
  87.  *      <li>
  88.  *          Carl, B., and I. Stephani (1990): <i>Entropy, Compactness, and the Approximation of Operators</i>
  89.  *              <b>Cambridge University Press</b> Cambridge UK 
  90.  *      </li>
  91.  *  </ul>
  92.  *
  93.  * <br><br>
  94.  *  <ul>
  95.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  96.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/StatisticalLearningLibrary.md">Statistical Learning Library</a></li>
  97.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/README.md">R<sup>1</sup> and R<sup>d</sup> Vector/Tensor Spaces (Validated and/or Normed), and Function Classes</a></li>
  98.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/functionclass/README.md">Normed Finite Spaces Function Class</a></li>
  99.  *  </ul>
  100.  * <br><br>
  101.  *
  102.  * @author Lakshmi Krishnamurthy
  103.  */

  105. public class NormedRxToNormedR1Finite extends org.drip.spaces.functionclass.NormedRxToNormedRxFinite {
  106.     private org.drip.spaces.rxtor1.NormedRxToNormedR1[] _aNormedRxToNormedR1 = null;

  108.     protected NormedRxToNormedR1Finite (
  109.         final double dblMaureyConstant,
  110.         final org.drip.spaces.rxtor1.NormedRxToNormedR1[] aNormedRxToNormedR1)
  111.         throws java.lang.Exception
  112.     {
  113.         super (dblMaureyConstant);

  115.         int iClassSize = null == (_aNormedRxToNormedR1 = aNormedRxToNormedR1) ? 0 :
  116.             _aNormedRxToNormedR1.length;

  118.         if (null != _aNormedRxToNormedR1 && 0 == iClassSize)
  119.             throw new java.lang.Exception ("NormedRxToNormedR1Finite ctr: Invalid Inputs");

  121.         for (int i = 0; i < iClassSize; ++i) {
  122.             if (null == _aNormedRxToNormedR1[i])
  123.                 throw new java.lang.Exception ("NormedRxToNormedR1Finite ctr: Invalid Inputs");
  124.         }
  125.     }

  127.     @Override public org.drip.spaces.cover.FunctionClassCoveringBounds agnosticCoveringNumberBounds()
  128.     {
  129.         return null;
  130.     }

  132.     @Override public org.drip.spaces.metric.GeneralizedMetricVectorSpace inputMetricVectorSpace()
  133.     {
  134.         return null == _aNormedRxToNormedR1 ? null : _aNormedRxToNormedR1[0].inputMetricVectorSpace();
  135.     }

  137.     @Override public org.drip.spaces.metric.R1Normed outputMetricVectorSpace()
  138.     {
  139.         return null == _aNormedRxToNormedR1 ? null : _aNormedRxToNormedR1[0].outputMetricVectorSpace();
  140.     }

  142.     /**
  143.      * Retrieve the Array of Function Spaces in the Class
  144.      * 
  145.      * @return The Array of Function Spaces in the Class
  146.      */

  148.     public org.drip.spaces.rxtor1.NormedRxToNormedR1[] functionSpaces()
  149.     {
  150.         return _aNormedRxToNormedR1;
  151.     }

  153.     /**
  154.      * Estimate for the Function Class Population Covering Number
  155.      * 
  156.      * @param dblCover The Size of the Cover
  157.      * 
  158.      * @return Function Class Population Covering Number Estimate
  159.      * 
  160.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  161.      */

  163.     public double populationCoveringNumber (
  164.         final double dblCover)
  165.         throws java.lang.Exception
  166.     {
  167.         if (null == _aNormedRxToNormedR1)
  168.             throw new java.lang.Exception
  169.                 ("NormedRxToNormedR1Finite::populationCoveringNumber => Finite Function Set Unspecified");

  171.         int iFunctionSpaceSize = _aNormedRxToNormedR1.length;

  173.         double dblPopulationCoveringNumber = _aNormedRxToNormedR1[0].populationCoveringNumber (dblCover);

  175.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPopulationCoveringNumber))
  176.             throw new java.lang.Exception
  177.                 ("NormedRxToNormedR1Finite::populationCoveringNumber => Cannot Compute Population Covering Number");

  179.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  180.             double dblFunctionPopulationCoveringNumber = _aNormedRxToNormedR1[i].populationCoveringNumber
  181.                 (dblCover);

  183.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblFunctionPopulationCoveringNumber))
  184.                 throw new java.lang.Exception
  185.                     ("NormedRxToNormedR1Finite::populationCoveringNumber => Cannot Compute Population Covering Number");

  187.             if (dblPopulationCoveringNumber < dblFunctionPopulationCoveringNumber)
  188.                 dblPopulationCoveringNumber = dblFunctionPopulationCoveringNumber;
  189.         }

  191.         return dblPopulationCoveringNumber;
  192.     }

  194.     /**
  195.      * Estimate for the Function Class Population Supremum Covering Number
  196.      * 
  197.      * @param dblCover The Size of the Cover
  198.      * 
  199.      * @return Function Class Population Supremum Covering Number Estimate
  200.      * 
  201.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  202.      */

  204.     public double populationSupremumCoveringNumber (
  205.         final double dblCover)
  206.         throws java.lang.Exception
  207.     {
  208.         if (null == _aNormedRxToNormedR1)
  209.             throw new java.lang.Exception
  210.                 ("NormedRxToNormedR1Finite::populationSupremumCoveringNumber => Finite Function Set Unspecified");

  212.         int iFunctionSpaceSize = _aNormedRxToNormedR1.length;

  214.         double dblPopulationSupremumCoveringNumber = _aNormedRxToNormedR1[0].populationSupremumCoveringNumber
  215.             (dblCover);

  217.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblPopulationSupremumCoveringNumber))
  218.             throw new java.lang.Exception
  219.                 ("NormedRxToNormedR1Finite::populationSupremumCoveringNumber => Cannot Compute Population Supremum Covering Number");

  221.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  222.             double dblFunctionPopulationSupremumCoveringNumber =
  223.                 _aNormedRxToNormedR1[i].populationSupremumCoveringNumber (dblCover);

  225.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblFunctionPopulationSupremumCoveringNumber))
  226.                 throw new java.lang.Exception
  227.                     ("NormedRxToNormedR1Finite::populationSupremumCoveringNumber => Cannot Compute Population Supremum Covering Number");

  229.             if (dblPopulationSupremumCoveringNumber < dblFunctionPopulationSupremumCoveringNumber)
  230.                 dblPopulationSupremumCoveringNumber = dblFunctionPopulationSupremumCoveringNumber;
  231.         }

  233.         return dblPopulationSupremumCoveringNumber;
  234.     }

  236.     /**
  237.      * Estimate for the Scale-Sensitive Sample Covering Number for the specified Cover Size
  238.      * 
  239.      * @param gvvi The Validated Instance Vector Sequence
  240.      * @param dblCover The Size of the Cover
  241.      * 
  242.      * @return The Scale-Sensitive Sample Covering Number for the specified Cover Size
  243.      * 
  244.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  245.      */

  247.     public double sampleCoveringNumber (
  248.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  249.         final double dblCover)
  250.         throws java.lang.Exception
  251.     {
  252.         if (null == _aNormedRxToNormedR1)
  253.             throw new java.lang.Exception
  254.                 ("NormedRxToNormedR1Finite::sampleCoveringNumber => Finite Function Set Unspecified");

  256.         int iFunctionSpaceSize = _aNormedRxToNormedR1.length;

  258.         double dblSampleCoveringNumber = _aNormedRxToNormedR1[0].sampleCoveringNumber (gvvi, dblCover);

  260.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblSampleCoveringNumber))
  261.             throw new java.lang.Exception
  262.                 ("NormedRxToNormedR1Finite::sampleCoveringNumber => Cannot Compute Sample Covering Number");

  264.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  265.             double dblFunctionSampleCoveringNumber = _aNormedRxToNormedR1[i].sampleCoveringNumber (gvvi,
  266.                 dblCover);

  268.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblFunctionSampleCoveringNumber))
  269.                 throw new java.lang.Exception
  270.                     ("NormedRxToNormedR1Finite::sampleCoveringNumber => Cannot Compute Sample Covering Number");

  272.             if (dblSampleCoveringNumber < dblFunctionSampleCoveringNumber)
  273.                 dblSampleCoveringNumber = dblFunctionSampleCoveringNumber;
  274.         }

  276.         return dblSampleCoveringNumber;
  277.     }

  279.     /**
  280.      * Estimate for the Scale-Sensitive Sample Supremum Covering Number for the specified Cover Size
  281.      * 
  282.      * @param gvvi The Validated Instance Vector Sequence
  283.      * @param dblCover The Size of the Cover
  284.      * 
  285.      * @return The Scale-Sensitive Sample Supremum Covering Number for the specified Cover Size
  286.      * 
  287.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  288.      */

  290.     public double sampleSupremumCoveringNumber (
  291.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  292.         final double dblCover)
  293.         throws java.lang.Exception
  294.     {
  295.         if (null == _aNormedRxToNormedR1)
  296.             throw new java.lang.Exception
  297.                 ("NormedRxToNormedR1Finite::sampleSupremumCoveringNumber => Finite Function Set Unspecified");

  299.         int iFunctionSpaceSize = _aNormedRxToNormedR1.length;

  301.         double dblSampleSupremumCoveringNumber = _aNormedRxToNormedR1[0].sampleSupremumCoveringNumber (gvvi,
  302.             dblCover);

  304.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblSampleSupremumCoveringNumber))
  305.             throw new java.lang.Exception
  306.                 ("NormedRxToNormedR1Finite::sampleSupremumCoveringNumber => Cannot Compute Sample Supremum Covering Number");

  308.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  309.             double dblFunctionSampleSupremumCoveringNumber =
  310.                 _aNormedRxToNormedR1[i].sampleSupremumCoveringNumber (gvvi, dblCover);

  312.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblFunctionSampleSupremumCoveringNumber))
  313.                 throw new java.lang.Exception
  314.                     ("NormedRxToNormedR1Finite::sampleSupremumCoveringNumber => Cannot Compute Sample Supremum Covering Number");

  316.             if (dblSampleSupremumCoveringNumber < dblFunctionSampleSupremumCoveringNumber)
  317.                 dblSampleSupremumCoveringNumber = dblFunctionSampleSupremumCoveringNumber;
  318.         }

  320.         return dblSampleSupremumCoveringNumber;
  321.     }

  323.     @Override public double operatorPopulationMetricNorm()
  324.         throws java.lang.Exception
  325.     {
  326.         if (null == _aNormedRxToNormedR1)
  327.             throw new java.lang.Exception
  328.                 ("NormedRxToNormedR1Finite::operatorPopulationMetricNorm => Finite Function Set Unspecified");

  330.         int iNumFunction = _aNormedRxToNormedR1.length;

  332.         double dblOperatorPopulationMetricNorm = _aNormedRxToNormedR1[0].populationMetricNorm();

  334.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblOperatorPopulationMetricNorm))
  335.             throw new java.lang.Exception
  336.                 ("NormedRxToNormedR1Finite::operatorPopulationMetricNorm => Cannot compute Population Metric Norm for Function #"
  337.                     + 0);

  339.         for (int i = 1; i < iNumFunction; ++i) {
  340.             double dblPopulationMetricNorm = _aNormedRxToNormedR1[i].populationMetricNorm();

  342.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblPopulationMetricNorm))
  343.                 throw new java.lang.Exception
  344.                     ("NormedRxToNormedR1Finite::operatorPopulationMetricNorm => Cannot compute Population Metric Norm for Function #"
  345.                         + i);

  347.             if (dblOperatorPopulationMetricNorm > dblPopulationMetricNorm)
  348.                 dblOperatorPopulationMetricNorm = dblPopulationMetricNorm;
  349.         }

  351.         return dblOperatorPopulationMetricNorm;
  352.     }

  354.     @Override public double operatorPopulationSupremumNorm()
  355.         throws java.lang.Exception
  356.     {
  357.         if (null == _aNormedRxToNormedR1)
  358.             throw new java.lang.Exception
  359.                 ("NormedRxToNormedR1Finite::operatorPopulationSupremumNorm => Finite Function Set Unspecified");

  361.         int iNumFunction = _aNormedRxToNormedR1.length;

  363.         double dblOperatorPopulationSupremumNorm = _aNormedRxToNormedR1[0].populationESS();

  365.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblOperatorPopulationSupremumNorm))
  366.             throw new java.lang.Exception
  367.                 ("NormedRxToNormedR1Finite::operatorPopulationSupremumNorm => Cannot compute Population Supremum Norm for Function #"
  368.                     + 0);

  370.         for (int i = 1; i < iNumFunction; ++i) {
  371.             double dblPopulationSupremumNorm = _aNormedRxToNormedR1[i].populationESS();

  373.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblPopulationSupremumNorm))
  374.                 throw new java.lang.Exception
  375.                     ("NormedRxToNormedR1Finite::operatorPopulationSupremumNorm => Cannot compute Population Supremum Norm for Function #"
  376.                         + i);

  378.             if (dblOperatorPopulationSupremumNorm > dblPopulationSupremumNorm)
  379.                 dblOperatorPopulationSupremumNorm = dblPopulationSupremumNorm;
  380.         }

  382.         return dblOperatorPopulationSupremumNorm;
  383.     }

  385.     @Override public double operatorSampleMetricNorm (
  386.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  387.         throws java.lang.Exception
  388.     {
  389.         if (null == _aNormedRxToNormedR1)
  390.             throw new java.lang.Exception
  391.                 ("NormedRxToNormedR1Finite::operatorSampleMetricNorm => Finite Function Set Unspecified");

  393.         int iNumFunction = _aNormedRxToNormedR1.length;

  395.         double dblOperatorSampleMetricNorm = _aNormedRxToNormedR1[0].sampleMetricNorm (gvvi);

  397.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblOperatorSampleMetricNorm))
  398.             throw new java.lang.Exception
  399.                 ("NormedRxToNormedR1Finite::operatorSampleMetricNorm => Cannot compute Sample Metric Norm for Function #"
  400.                     + 0);

  402.         for (int i = 1; i < iNumFunction; ++i) {
  403.             double dblSampleMetricNorm = _aNormedRxToNormedR1[i].sampleMetricNorm (gvvi);

  405.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblSampleMetricNorm))
  406.                 throw new java.lang.Exception
  407.                     ("NormedRxToNormedR1Finite::operatorSampleMetricNorm => Cannot compute Sample Metric Norm for Function #"
  408.                         + i);

  410.             if (dblOperatorSampleMetricNorm > dblSampleMetricNorm)
  411.                 dblOperatorSampleMetricNorm = dblSampleMetricNorm;
  412.         }

  414.         return dblOperatorSampleMetricNorm;
  415.     }

  417.     @Override public double operatorSampleSupremumNorm (
  418.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  419.         throws java.lang.Exception
  420.     {
  421.         if (null == _aNormedRxToNormedR1)
  422.             throw new java.lang.Exception
  423.                 ("NormedRxToNormedR1Finite::operatorSampleSupremumNorm => Finite Function Set Unspecified");

  425.         int iNumFunction = _aNormedRxToNormedR1.length;

  427.         double dblOperatorSampleSupremumNorm = _aNormedRxToNormedR1[0].sampleSupremumNorm (gvvi);

  429.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblOperatorSampleSupremumNorm))
  430.             throw new java.lang.Exception
  431.                 ("NormedRxToNormedR1Finite::operatorSampleSupremumNorm => Cannot compute Sample Supremum Norm for Function #"
  432.                     + 0);

  434.         for (int i = 1; i < iNumFunction; ++i) {
  435.             double dblSampleSupremumNorm = _aNormedRxToNormedR1[i].sampleSupremumNorm (gvvi);

  437.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblSampleSupremumNorm))
  438.                 throw new java.lang.Exception
  439.                     ("NormedRxToNormedR1Finite::operatorSampleSupremumNorm => Cannot compute Sample Supremum Norm for Function #"
  440.                         + i);

  442.             if (dblOperatorSampleSupremumNorm > dblSampleSupremumNorm)
  443.                 dblOperatorSampleSupremumNorm = dblSampleSupremumNorm;
  444.         }

  446.         return dblOperatorSampleSupremumNorm;
  447.     }
  448. }
Created with JaCoCo 0.7.9.201702052155