NormedRxToNormedRdFinite.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>NormedRxToNormedRdFinite</i> implements the Class F with f E f : Normed R<sup>x</sup> To Normed
  83.  * R<sup>d</sup> Space of Finite Functions. The References are:
  84.  *
  85.  * <br><br>
  86.  *  <ul>
  87.  *      <li>
  88.  *          Carl, B. (1985): Inequalities of the Bernstein-Jackson type and the Degree of Compactness of
  89.  *              Operators in Banach Spaces <i>Annals of the Fourier Institute</i> <b>35 (3)</b> 79-118
  90.  *      </li>
  91.  *      <li>
  92.  *          Carl, B., and I. Stephani (1990): <i>Entropy, Compactness, and the Approximation of Operators</i>
  93.  *              <b>Cambridge University Press</b> Cambridge UK 
  94.  *      </li>
  95.  *      <li>
  96.  *          Williamson, R. C., A. J. Smola, and B. Scholkopf (2000): Entropy Numbers of Linear Function
  97.  *              Classes, in: <i>Proceedings of the 13th Annual Conference on Computational Learning
  98.  *                  Theory</i> <b>ACM</b> New York
  99.  *      </li>
  100.  *  </ul>
  101.  *
  102.  * <br><br>
  103.  *  <ul>
  104.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  105.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/StatisticalLearningLibrary.md">Statistical Learning Library</a></li>
  106.  *      <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>
  107.  *      <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>
  108.  *  </ul>
  109.  * <br><br>
  110.  *
  111.  * @author Lakshmi Krishnamurthy
  112.  */

  114. public class NormedRxToNormedRdFinite extends org.drip.spaces.functionclass.NormedRxToNormedRxFinite {
  115.     private org.drip.spaces.rxtord.NormedRxToNormedRd[] _aNormedRxToNormedRd = null;

  117.     /**
  118.      * NormedRxToNormedRdFinite Constructor
  119.      * 
  120.      * @param dblMaureyConstant Maurey Constant
  121.      * @param aNormedRxToNormedRd Array of the Normed R^x To Normed R^d Spaces
  122.      *  
  123.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  124.      */

  126.     public NormedRxToNormedRdFinite (
  127.         final double dblMaureyConstant,
  128.         final org.drip.spaces.rxtord.NormedRxToNormedRd[] aNormedRxToNormedRd)
  129.         throws java.lang.Exception
  130.     {
  131.         super (dblMaureyConstant);

  133.         int iClassSize = null == (_aNormedRxToNormedRd = aNormedRxToNormedRd) ? 0 :
  134.             _aNormedRxToNormedRd.length;

  136.         if (null != _aNormedRxToNormedRd && 0 == iClassSize)
  137.             throw new java.lang.Exception ("NormedRxToNormedRdFinite ctr: Invalid Inputs");

  139.         for (int i = 0; i < iClassSize; ++i) {
  140.             if (null == _aNormedRxToNormedRd[i])
  141.                 throw new java.lang.Exception ("NormedRxToNormedRdFinite ctr: Invalid Inputs");
  142.         }
  143.     }

  145.     @Override public org.drip.spaces.cover.FunctionClassCoveringBounds agnosticCoveringNumberBounds()
  146.     {
  147.         return null;
  148.     }

  150.     @Override public org.drip.spaces.metric.GeneralizedMetricVectorSpace inputMetricVectorSpace()
  151.     {
  152.         return null == _aNormedRxToNormedRd ? null : _aNormedRxToNormedRd[0].inputMetricVectorSpace();
  153.     }

  155.     @Override public org.drip.spaces.metric.RdNormed outputMetricVectorSpace()
  156.     {
  157.         return null == _aNormedRxToNormedRd ? null : _aNormedRxToNormedRd[0].outputMetricVectorSpace();
  158.     }

  160.     /**
  161.      * Retrieve the Array of Function Spaces in the Class
  162.      * 
  163.      * @return The Array of Function Spaces in the Class
  164.      */

  166.     public org.drip.spaces.rxtord.NormedRxToNormedRd[] functionSpaces()
  167.     {
  168.         return _aNormedRxToNormedRd;
  169.     }

  171.     /**
  172.      * Estimate for the Function Class Population Covering Number Array, one for each dimension
  173.      * 
  174.      * @param adblCover The Size of the Cover Array
  175.      * 
  176.      * @return Function Class Population Covering Number Estimate Array, one for each dimension
  177.      */

  179.     public double[] populationCoveringNumber (
  180.         final double[] adblCover)
  181.     {
  182.         if (null == _aNormedRxToNormedRd || null == adblCover) return null;

  184.         int iFunctionSpaceSize = _aNormedRxToNormedRd.length;

  186.         if (iFunctionSpaceSize != adblCover.length) return null;

  188.         double[] adblPopulationCoveringNumber = _aNormedRxToNormedRd[0].populationCoveringNumber
  189.             (adblCover[0]);

  191.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblPopulationCoveringNumber)) return null;

  193.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  194.             double[] adblFunctionPopulationCoveringNumber = _aNormedRxToNormedRd[i].populationCoveringNumber
  195.                 (adblCover[i]);

  197.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblFunctionPopulationCoveringNumber))
  198.                 return null;

  200.             int iDimension = adblFunctionPopulationCoveringNumber.length;

  202.             for (int j = 0; j < iDimension; ++j) {
  203.                 if (adblPopulationCoveringNumber[j] < adblFunctionPopulationCoveringNumber[j])
  204.                     adblPopulationCoveringNumber[j] = adblFunctionPopulationCoveringNumber[j];
  205.             }
  206.         }

  208.         return adblPopulationCoveringNumber;
  209.     }

  211.     /**
  212.      * Estimate for the Function Class Population Covering Number Array, one for each dimension
  213.      * 
  214.      * @param dblCover The Cover
  215.      * 
  216.      * @return Function Class Population Covering Number Estimate Array, one for each dimension
  217.      */

  219.     public double[] populationCoveringNumber (
  220.         final double dblCover)
  221.     {
  222.         int iDimension = outputMetricVectorSpace().dimension();

  224.         double[] adblCover = new double[iDimension];

  226.         for (int i = 0; i < iDimension; ++i)
  227.             adblCover[i] = dblCover;

  229.         return populationCoveringNumber (adblCover);
  230.     }

  232.     /**
  233.      * Estimate for the Function Class Population Supremum Covering Number Array, one for each dimension
  234.      * 
  235.      * @param adblCover The Size of the Cover Array
  236.      * 
  237.      * @return Function Class Population Supremum Covering Number Estimate Array, one for each dimension
  238.      */

  240.     public double[] populationSupremumCoveringNumber (
  241.         final double[] adblCover)
  242.     {
  243.         if (null == _aNormedRxToNormedRd || null == adblCover) return null;

  245.         int iFunctionSpaceSize = _aNormedRxToNormedRd.length;

  247.         if (iFunctionSpaceSize != adblCover.length) return null;

  249.         double[] adblPopulationSupremumCoveringNumber =
  250.             _aNormedRxToNormedRd[0].populationSupremumCoveringNumber (adblCover[0]);

  252.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblPopulationSupremumCoveringNumber)) return null;

  254.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  255.             double[] adblFunctionPopulationSupremumCoveringNumber =
  256.                 _aNormedRxToNormedRd[i].populationSupremumCoveringNumber (adblCover[i]);

  258.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblFunctionPopulationSupremumCoveringNumber))
  259.                 return null;

  261.             int iDimension = adblFunctionPopulationSupremumCoveringNumber.length;

  263.             for (int j = 0; j < iDimension; ++j) {
  264.                 if (adblPopulationSupremumCoveringNumber[j] <
  265.                     adblFunctionPopulationSupremumCoveringNumber[j])
  266.                     adblPopulationSupremumCoveringNumber[j] =
  267.                         adblFunctionPopulationSupremumCoveringNumber[j];
  268.             }
  269.         }

  271.         return adblPopulationSupremumCoveringNumber;
  272.     }

  274.     /**
  275.      * Estimate for the Function Class Population Supremum Covering Number Array, one for each dimension
  276.      * 
  277.      * @param dblCover The Cover
  278.      * 
  279.      * @return Function Class Population Covering Supremum Number Estimate Array, one for each dimension
  280.      */

  282.     public double[] populationSupremumCoveringNumber (
  283.         final double dblCover)
  284.     {
  285.         int iDimension = outputMetricVectorSpace().dimension();

  287.         double[] adblCover = new double[iDimension];

  289.         for (int i = 0; i < iDimension; ++i)
  290.             adblCover[i] = dblCover;

  292.         return populationSupremumCoveringNumber (adblCover);
  293.     }

  295.     /**
  296.      * Estimate for the Scale-Sensitive Sample Covering Number Array for the specified Cover Size
  297.      * 
  298.      * @param gvvi The Validated Instance Vector Sequence
  299.      * @param adblCover The Size of the Cover Array
  300.      * 
  301.      * @return The Scale-Sensitive Sample Covering Number Array for the specified Cover Size
  302.      */

  304.     public double[] sampleCoveringNumber (
  305.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  306.         final double[] adblCover)
  307.     {
  308.         if (null == _aNormedRxToNormedRd || null == adblCover) return null;

  310.         int iFunctionSpaceSize = _aNormedRxToNormedRd.length;

  312.         if (iFunctionSpaceSize != adblCover.length) return null;

  314.         double[] adblSampleCoveringNumber = _aNormedRxToNormedRd[0].sampleCoveringNumber (gvvi,
  315.             adblCover[0]);

  317.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblSampleCoveringNumber)) return null;

  319.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  320.             double[] adblFunctionSampleCoveringNumber = _aNormedRxToNormedRd[i].sampleCoveringNumber (gvvi,
  321.                 adblCover[i]);

  323.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblFunctionSampleCoveringNumber)) return null;

  325.             int iDimension = adblFunctionSampleCoveringNumber.length;

  327.             for (int j = 0; j < iDimension; ++j) {
  328.                 if (adblSampleCoveringNumber[j] < adblFunctionSampleCoveringNumber[j])
  329.                     adblSampleCoveringNumber[j] = adblFunctionSampleCoveringNumber[j];
  330.             }
  331.         }

  333.         return adblSampleCoveringNumber;
  334.     }

  336.     /**
  337.      * Estimate for the Scale-Sensitive Sample Covering Number Array for the specified Cover Size
  338.      * 
  339.      * @param gvvi The Validated Instance Vector Sequence
  340.      * @param dblCover The Size of the Cover Array
  341.      * 
  342.      * @return The Scale-Sensitive Sample Covering Number Array for the specified Cover Size
  343.      */

  345.     public double[] sampleCoveringNumber (
  346.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  347.         final double dblCover)
  348.     {
  349.         int iDimension = outputMetricVectorSpace().dimension();

  351.         double[] adblCover = new double[iDimension];

  353.         for (int i = 0; i < iDimension; ++i)
  354.             adblCover[i] = dblCover;

  356.         return sampleCoveringNumber (gvvi, adblCover);
  357.     }

  359.     /**
  360.      * Estimate for the Scale-Sensitive Sample Supremum Covering Number for the specified Cover Size
  361.      * 
  362.      * @param gvvi The Validated Instance Vector Sequence
  363.      * @param adblCover The Size of the Cover Array
  364.      * 
  365.      * @return The Scale-Sensitive Sample Supremum Covering Number for the specified Cover Size
  366.      */

  368.     public double[] sampleSupremumCoveringNumber (
  369.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  370.         final double[] adblCover)
  371.     {
  372.         if (null == _aNormedRxToNormedRd || null == adblCover) return null;

  374.         int iFunctionSpaceSize = _aNormedRxToNormedRd.length;

  376.         if (iFunctionSpaceSize != adblCover.length) return null;

  378.         double[] adblSampleSupremumCoveringNumber = _aNormedRxToNormedRd[0].sampleSupremumCoveringNumber
  379.             (gvvi, adblCover[0]);

  381.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblSampleSupremumCoveringNumber)) return null;

  383.         for (int i = 1; i < iFunctionSpaceSize; ++i) {
  384.             double[] adblFunctionSampleSupremumCoveringNumber =
  385.                 _aNormedRxToNormedRd[i].sampleSupremumCoveringNumber (gvvi, adblCover[i]);

  387.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblFunctionSampleSupremumCoveringNumber))
  388.                 return null;

  390.             int iDimension = adblFunctionSampleSupremumCoveringNumber.length;

  392.             for (int j = 0; j < iDimension; ++j) {
  393.                 if (adblSampleSupremumCoveringNumber[j] < adblFunctionSampleSupremumCoveringNumber[j])
  394.                     adblSampleSupremumCoveringNumber[j] = adblFunctionSampleSupremumCoveringNumber[j];
  395.             }
  396.         }

  398.         return adblSampleSupremumCoveringNumber;
  399.     }

  401.     /**
  402.      * Estimate for the Scale-Sensitive Sample Supremum Covering Number for the specified Cover Size
  403.      * 
  404.      * @param gvvi The Validated Instance Vector Sequence
  405.      * @param dblCover The Cover
  406.      * 
  407.      * @return The Scale-Sensitive Sample Supremum Covering Number for the specified Cover Size
  408.      */

  410.     public double[] sampleSupremumCoveringNumber (
  411.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi,
  412.         final double dblCover)
  413.     {
  414.         int iDimension = outputMetricVectorSpace().dimension();

  416.         double[] adblCover = new double[iDimension];

  418.         for (int i = 0; i < iDimension; ++i)
  419.             adblCover[i] = dblCover;

  421.         return sampleSupremumCoveringNumber (gvvi, adblCover);
  422.     }

  424.     /**
  425.      * Compute the Population R^d Metric Norm
  426.      * 
  427.      * @return The Population R^d Metric Norm
  428.      */

  430.     public double[] populationRdMetricNorm()
  431.     {
  432.         if (null == _aNormedRxToNormedRd) return null;

  434.         int iNumFunction = _aNormedRxToNormedRd.length;

  436.         double[] adblPopulationRdMetricNorm = _aNormedRxToNormedRd[0].populationMetricNorm();

  438.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblPopulationRdMetricNorm)) return null;

  440.         for (int i = 1; i < iNumFunction; ++i) {
  441.             double[] adblPopulationMetricNorm = _aNormedRxToNormedRd[i].populationMetricNorm();

  443.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblPopulationMetricNorm)) return null;

  445.             int iDimension = adblPopulationMetricNorm.length;

  447.             for (int j = 0; j < iDimension; ++j) {
  448.                 if (adblPopulationRdMetricNorm[j] < adblPopulationMetricNorm[j])
  449.                     adblPopulationRdMetricNorm[j] = adblPopulationMetricNorm[j];
  450.             }
  451.         }

  453.         return adblPopulationRdMetricNorm;
  454.     }

  456.     /**
  457.      * Compute the Population R^d Supremum Norm
  458.      * 
  459.      * @return The Population R^d Supremum Norm
  460.      */

  462.     public double[] populationRdSupremumNorm()
  463.     {
  464.         if (null == _aNormedRxToNormedRd) return null;

  466.         int iNumFunction = _aNormedRxToNormedRd.length;

  468.         double[] adblPopulationRdSupremumNorm = _aNormedRxToNormedRd[0].populationESS();

  470.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblPopulationRdSupremumNorm)) return null;

  472.         for (int i = 1; i < iNumFunction; ++i) {
  473.             double[] adblPopulationSupremumNorm = _aNormedRxToNormedRd[i].populationESS();

  475.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblPopulationSupremumNorm)) return null;

  477.             int iDimension = adblPopulationSupremumNorm.length;

  479.             for (int j = 0; j < iDimension; ++j) {
  480.                 if (adblPopulationRdSupremumNorm[j] < adblPopulationSupremumNorm[j])
  481.                     adblPopulationRdSupremumNorm[j] = adblPopulationSupremumNorm[j];
  482.             }
  483.         }

  485.         return adblPopulationRdSupremumNorm;
  486.     }

  488.     /**
  489.      * Compute the Sample R^d Metric Norm
  490.      * 
  491.      * @param gvvi The Validated Vector Space Instance
  492.      * 
  493.      * @return The Sample R^d Metric Norm
  494.      */

  496.     public double[] sampleRdMetricNorm (
  497.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  498.     {
  499.         if (null == _aNormedRxToNormedRd) return null;

  501.         int iNumFunction = _aNormedRxToNormedRd.length;

  503.         double[] adblSampleRdMetricNorm = _aNormedRxToNormedRd[0].sampleMetricNorm (gvvi);

  505.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblSampleRdMetricNorm)) return null;

  507.         for (int i = 1; i < iNumFunction; ++i) {
  508.             double[] adblSampleMetricNorm = _aNormedRxToNormedRd[i].sampleMetricNorm (gvvi);

  510.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblSampleMetricNorm)) return null;

  512.             int iDimension = adblSampleMetricNorm.length;

  514.             for (int j = 0; j < iDimension; ++j) {
  515.                 if (adblSampleRdMetricNorm[j] < adblSampleMetricNorm[j])
  516.                     adblSampleRdMetricNorm[j] = adblSampleMetricNorm[j];
  517.             }
  518.         }

  520.         return adblSampleRdMetricNorm;
  521.     }

  523.     /**
  524.      * Compute the Sample R^d Supremum Norm
  525.      * 
  526.      * @param gvvi The Validated Vector Space Instance
  527.      * 
  528.      * @return The Sample R^d Supremum Norm
  529.      */

  531.     public double[] sampleRdSupremumNorm (
  532.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  533.     {
  534.         if (null == _aNormedRxToNormedRd) return null;

  536.         int iNumFunction = _aNormedRxToNormedRd.length;

  538.         double[] adblSampleRdSupremumNorm = _aNormedRxToNormedRd[0].sampleSupremumNorm (gvvi);

  540.         if (!org.drip.numerical.common.NumberUtil.IsValid (adblSampleRdSupremumNorm)) return null;

  542.         for (int i = 1; i < iNumFunction; ++i) {
  543.             double[] adblSampleSupremumNorm = _aNormedRxToNormedRd[i].sampleSupremumNorm (gvvi);

  545.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblSampleSupremumNorm)) return null;

  547.             int iDimension = adblSampleSupremumNorm.length;

  549.             for (int j = 0; j < iDimension; ++j) {
  550.                 if (adblSampleRdSupremumNorm[j] < adblSampleSupremumNorm[j])
  551.                     adblSampleRdSupremumNorm[j] = adblSampleSupremumNorm[j];
  552.             }
  553.         }

  555.         return adblSampleRdSupremumNorm;
  556.     }

  558.     @Override public double operatorPopulationMetricNorm()
  559.         throws java.lang.Exception
  560.     {
  561.         double[] adblPopulationMetricNorm = populationRdMetricNorm();

  563.         if (null == adblPopulationMetricNorm)
  564.             throw new java.lang.Exception
  565.                 ("NormedRxToNormedRdFinite::operatorPopulationMetricNorm => Invalid Inputs");

  567.         int iDimension = adblPopulationMetricNorm.length;
  568.         double dblOperatorPopulationMetricNorm = java.lang.Double.NaN;

  570.         if (0 == iDimension)
  571.             throw new java.lang.Exception
  572.                 ("NormedRxToNormedRdFinite::operatorPopulationMetricNorm => Invalid Inputs");

  574.         for (int j = 0; j < iDimension; ++j) {
  575.             if (0 == j)
  576.                 dblOperatorPopulationMetricNorm = adblPopulationMetricNorm[j];
  577.             else {
  578.                 if (dblOperatorPopulationMetricNorm < adblPopulationMetricNorm[j])
  579.                     dblOperatorPopulationMetricNorm = adblPopulationMetricNorm[j];
  580.             }
  581.         }

  583.         return dblOperatorPopulationMetricNorm;
  584.     }

  586.     @Override public double operatorPopulationSupremumNorm()
  587.         throws java.lang.Exception
  588.     {
  589.         double[] adblPopulationSupremumNorm = populationRdSupremumNorm();

  591.         if (null == adblPopulationSupremumNorm)
  592.             throw new java.lang.Exception
  593.                 ("NormedRxToNormedRdFinite::operatorPopulationSupremumNorm => Invalid Inputs");

  595.         int iDimension = adblPopulationSupremumNorm.length;
  596.         double dblOperatorPopulationSupremumNorm = java.lang.Double.NaN;

  598.         if (0 == iDimension)
  599.             throw new java.lang.Exception
  600.                 ("NormedRxToNormedRdFinite::operatorPopulationSupremumNorm => Invalid Inputs");

  602.         for (int j = 0; j < iDimension; ++j) {
  603.             if (0 == j)
  604.                 dblOperatorPopulationSupremumNorm = adblPopulationSupremumNorm[j];
  605.             else {
  606.                 if (dblOperatorPopulationSupremumNorm < adblPopulationSupremumNorm[j])
  607.                     dblOperatorPopulationSupremumNorm = adblPopulationSupremumNorm[j];
  608.             }
  609.         }

  611.         return dblOperatorPopulationSupremumNorm;
  612.     }

  614.     @Override public double operatorSampleMetricNorm (
  615.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  616.         throws java.lang.Exception
  617.     {
  618.         double[] adblSampleMetricNorm = sampleRdMetricNorm (gvvi);

  620.         if (null == adblSampleMetricNorm)
  621.             throw new java.lang.Exception
  622.                 ("NormedRxToNormedRdFinite::operatorSampleMetricNorm => Invalid Inputs");

  624.         int iDimension = adblSampleMetricNorm.length;
  625.         double dblOperatorSampleMetricNorm = java.lang.Double.NaN;

  627.         if (0 == iDimension)
  628.             throw new java.lang.Exception
  629.                 ("NormedRxToNormedRdFinite::operatorSampleMetricNorm => Invalid Inputs");

  631.         for (int j = 0; j < iDimension; ++j) {
  632.             if (0 == j)
  633.                 dblOperatorSampleMetricNorm = adblSampleMetricNorm[j];
  634.             else {
  635.                 if (dblOperatorSampleMetricNorm < adblSampleMetricNorm[j])
  636.                     dblOperatorSampleMetricNorm = adblSampleMetricNorm[j];
  637.             }
  638.         }

  640.         return dblOperatorSampleMetricNorm;
  641.     }

  643.     @Override public double operatorSampleSupremumNorm (
  644.         final org.drip.spaces.instance.GeneralizedValidatedVector gvvi)
  645.         throws java.lang.Exception
  646.     {
  647.         double[] adblSampleSupremumNorm = sampleRdSupremumNorm (gvvi);

  649.         if (null == adblSampleSupremumNorm)
  650.             throw new java.lang.Exception
  651.                 ("NormedRxToNormedRdFinite::operatorSampleSupremumNorm => Invalid Inputs");

  653.         int iDimension = adblSampleSupremumNorm.length;
  654.         double dblOperatorSampleSupremumNorm = java.lang.Double.NaN;

  656.         if (0 == iDimension)
  657.             throw new java.lang.Exception
  658.                 ("NormedRxToNormedRdFinite::operatorSampleSupremumNorm => Invalid Inputs");

  660.         for (int j = 0; j < iDimension; ++j) {
  661.             if (0 == j)
  662.                 dblOperatorSampleSupremumNorm = adblSampleSupremumNorm[j];
  663.             else {
  664.                 if (dblOperatorSampleSupremumNorm < adblSampleSupremumNorm[j])
  665.                     dblOperatorSampleSupremumNorm = adblSampleSupremumNorm[j];
  666.             }
  667.         }

  669.         return dblOperatorSampleSupremumNorm;
  670.     }
  671. }
Created with JaCoCo 0.7.9.201702052155