SingleSequenceAgnosticMetrics.java

  1. package org.drip.sequence.metrics;

  3. /*
  4.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  5.  */

  7. /*!
  8.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  9.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  10.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  11.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  12.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  13.  * 
  14.  *  This file is part of DROP, an open-source library targeting risk, transaction costs, exposure, margin
  15.  *      calculations, and portfolio construction within and across fixed income, credit, commodity, equity,
  16.  *      FX, and structured products.
  17.  *  
  18.  *      https://lakshmidrip.github.io/DROP/
  19.  *  
  20.  *  DROP is composed of three main modules:
  21.  *  
  22.  *  - DROP Analytics Core - https://lakshmidrip.github.io/DROP-Analytics-Core/
  23.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  24.  *  - DROP Numerical Core - https://lakshmidrip.github.io/DROP-Numerical-Core/
  25.  * 
  26.  *  DROP Analytics Core implements libraries for the following:
  27.  *  - Fixed Income Analytics
  28.  *  - Asset Backed Analytics
  29.  *  - XVA Analytics
  30.  *  - Exposure and Margin Analytics
  31.  * 
  32.  *  DROP Portfolio Core implements libraries for the following:
  33.  *  - Asset Allocation Analytics
  34.  *  - Transaction Cost Analytics
  35.  * 
  36.  *  DROP Numerical Core implements libraries for the following:
  37.  *  - Statistical Learning Library
  38.  *  - Numerical Optimizer Library
  39.  *  - Machine Learning Library
  40.  *  - Spline Builder Library
  41.  * 
  42.  *  Documentation for DROP is Spread Over:
  43.  * 
  44.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  45.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  46.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  47.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  48.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  49.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  50.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  51.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  52.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  53.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  54.  * 
  55.  *  Licensed under the Apache License, Version 2.0 (the "License");
  56.  *      you may not use this file except in compliance with the License.
  57.  *   
  58.  *  You may obtain a copy of the License at
  59.  *      http://www.apache.org/licenses/LICENSE-2.0
  60.  *  
  61.  *  Unless required by applicable law or agreed to in writing, software
  62.  *      distributed under the License is distributed on an "AS IS" BASIS,
  63.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  64.  *  
  65.  *  See the License for the specific language governing permissions and
  66.  *      limitations under the License.
  67.  */

  69. /**
  70.  * <i>SingleSequenceAgnosticMetrics</i> contains the Sample Distribution Metrics and Agnostic Bounds related
  71.  * to the specified Sequence.
  72.  * 
  73.  * <br><br>
  74.  *  <ul>
  75.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalCore.md">Numerical Core Module</a></li>
  76.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/StatisticalLearningLibrary.md">Statistical Learning Library</a></li>
  77.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sequence">Sequence</a></li>
  78.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sequence/metrics">Metrics</a></li>
  79.  *  </ul>
  80.  * <br><br>
  81.  *
  82.  * @author Lakshmi Krishnamurthy
  83.  */

  85. public class SingleSequenceAgnosticMetrics {
  86.     private boolean _bIsPositive = true;
  87.     private double[] _adblSequence = null;
  88.     private double _dblEmpiricalVariance = java.lang.Double.NaN;
  89.     private double _dblEmpiricalExpectation = java.lang.Double.NaN;
  90.     private org.drip.measure.continuous.R1Univariate _distPopulation = null;

  92.     /**
  93.      * Build out the Sequence and their Metrics
  94.      * 
  95.      * @param adblSequence Array of Sequence Entries
  96.      * @param distPopulation The True Underlying Generator Distribution of the Population
  97.      * 
  98.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  99.      */

  101.     public SingleSequenceAgnosticMetrics (
  102.         final double[] adblSequence,
  103.         final org.drip.measure.continuous.R1Univariate distPopulation)
  104.         throws java.lang.Exception
  105.     {
  106.         if (null == (_adblSequence = adblSequence))
  107.             throw new java.lang.Exception ("SingleSequenceAgnosticMetrics ctr: Invalid Inputs");

  109.         _dblEmpiricalExpectation = 0.;
  110.         _distPopulation = distPopulation;
  111.         int iNumEntry = _adblSequence.length;

  113.         if (0 == iNumEntry)
  114.             throw new java.lang.Exception ("SingleSequenceAgnosticMetrics ctr: Invalid Inputs");

  116.         for (int i = 0; i < iNumEntry; ++i) {
  117.             if (!org.drip.numerical.common.NumberUtil.IsValid (_adblSequence[i]))
  118.                 throw new java.lang.Exception ("SingleSequenceAgnosticMetrics ctr: Invalid Inputs");

  120.             _dblEmpiricalExpectation += _adblSequence[i];

  122.             if (_adblSequence[i] < 0.) _bIsPositive = false;
  123.         }

  125.         _dblEmpiricalVariance = 0.;
  126.         _dblEmpiricalExpectation /= iNumEntry;

  128.         for (int i = 0; i < iNumEntry; ++i)
  129.             _dblEmpiricalVariance += (_adblSequence[i] - _dblEmpiricalExpectation) * (_adblSequence[i] -
  130.                 _dblEmpiricalExpectation);

  132.         _dblEmpiricalVariance /= iNumEntry;
  133.     }

  135.     /**
  136.      * Compute the Specified Central Moment of the Sample Sequence
  137.      * 
  138.      * @param iMoment The Moment
  139.      * @param bAbsolute TRUE - The Moment sought is on the Absolute Value
  140.      * 
  141.      * @return The Specified Central Moment of the Sample Sequence
  142.      * 
  143.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  144.      */

  146.     public double empiricalCentralMoment (
  147.         final int iMoment,
  148.         final boolean bAbsolute)
  149.         throws java.lang.Exception
  150.     {
  151.         if (0 >= iMoment)
  152.             throw new java.lang.Exception
  153.                 ("SingleSequenceAgnosticMetrics::empiricalCentralMoment => Invalid Moment");

  155.         double dblMoment = 0.;
  156.         int iNumEntry = _adblSequence.length;

  158.         for (int i = 0; i < iNumEntry; ++i) {
  159.             double dblDeparture = _adblSequence[i] - _dblEmpiricalExpectation;

  161.             dblMoment += java.lang.Math.pow (bAbsolute ? java.lang.Math.abs (dblDeparture) : dblDeparture,
  162.                 iMoment);
  163.         }

  165.         return dblMoment / iNumEntry;
  166.     }

  168.     /**
  169.      * Compute the Specified Raw Moment of the Sample Sequence
  170.      * 
  171.      * @param iMoment The Moment
  172.      * @param bAbsolute TRUE - The Moment sought is on the Absolute Value
  173.      * 
  174.      * @return The Specified Raw Moment of the Sample Sequence
  175.      * 
  176.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  177.      */

  179.     public double empiricalRawMoment (
  180.         final int iMoment,
  181.         final boolean bAbsolute)
  182.         throws java.lang.Exception
  183.     {
  184.         if (0 >= iMoment)
  185.             throw new java.lang.Exception
  186.                 ("SingleSequenceAgnosticMetrics::empiricalRawMoment => Invalid Moment");

  188.         double dblMoment = 0.;
  189.         int iNumEntry = _adblSequence.length;

  191.         for (int i = 0; i < iNumEntry; ++i)
  192.             dblMoment += java.lang.Math.pow (bAbsolute ? java.lang.Math.abs (_adblSequence[i]) :
  193.                 _adblSequence[i], iMoment);

  195.         return dblMoment / iNumEntry;
  196.     }

  198.     /**
  199.      * Compute the Specified Anchor Moment of the Sample Sequence
  200.      * 
  201.      * @param iMoment The Moment
  202.      * @param dblAnchor The Anchor Pivot off of which the Moment is calculated
  203.      * @param bAbsolute TRUE - The Moment sought is on the Absolute Value
  204.      * 
  205.      * @return The Specified Anchor Moment of the Sample Sequence
  206.      * 
  207.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  208.      */

  210.     public double empiricalAnchorMoment (
  211.         final int iMoment,
  212.         final double dblAnchor,
  213.         final boolean bAbsolute)
  214.         throws java.lang.Exception
  215.     {
  216.         if (0 >= iMoment || !org.drip.numerical.common.NumberUtil.IsValid (dblAnchor))
  217.             throw new java.lang.Exception
  218.                 ("SingleSequenceAgnosticMetrics::empiricalAnchorMoment => Invalid Inputs");

  220.         double dblMoment = 0.;
  221.         int iNumEntry = _adblSequence.length;

  223.         for (int i = 0; i < iNumEntry; ++i) {
  224.             double dblPivotShift = _adblSequence[i] - dblAnchor;

  226.             dblMoment += java.lang.Math.pow (bAbsolute ? java.lang.Math.abs (dblPivotShift) : dblPivotShift,
  227.                 iMoment);
  228.         }

  230.         return dblMoment / iNumEntry;
  231.     }

  233.     /**
  234.      * Generate the Metrics for the Univariate Function Sequence
  235.      *  
  236.      * @param au The Univariate Function
  237.      * 
  238.      * @return Metrics for the Univariate Function Sequence
  239.      */

  241.     public SingleSequenceAgnosticMetrics functionSequenceMetrics (
  242.         final org.drip.function.definition.R1ToR1 au)
  243.     {
  244.         if (null == au) return null;

  246.         int iNumEntry = _adblSequence.length;
  247.         double[] adblFunctionMetrics = new double[iNumEntry];

  249.         try {
  250.             for (int i = 0; i < iNumEntry; ++i)
  251.                 adblFunctionMetrics[i] = au.evaluate (_adblSequence[i]);

  253.             return new SingleSequenceAgnosticMetrics (adblFunctionMetrics, null);
  254.         } catch (java.lang.Exception e) {
  255.             e.printStackTrace();
  256.         }

  258.         return null;
  259.     }

  261.     /**
  262.      * Retrieve the Population Distribution
  263.      * 
  264.      * @return The Population Distribution
  265.      */

  267.     public org.drip.measure.continuous.R1Univariate populationDistribution()
  268.     {
  269.         return _distPopulation;
  270.     }

  272.     /**
  273.      * Retrieve the Sample Expectation
  274.      * 
  275.      * @return The Sample Expectation
  276.      */

  278.     public double empiricalExpectation()
  279.     {
  280.         return _dblEmpiricalExpectation;
  281.     }

  283.     /**
  284.      * Retrieve the Population Mean
  285.      * 
  286.      * @return The Population Mean
  287.      * 
  288.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  289.      */

  291.     public double populationMean()
  292.         throws java.lang.Exception
  293.     {
  294.         return null == _distPopulation ? java.lang.Double.NaN : _distPopulation.mean();
  295.     }

  297.     /**
  298.      * Retrieve the Sample Variance
  299.      * 
  300.      * @return The Sample Variance
  301.      */

  303.     public double empiricalVariance()
  304.     {
  305.         return _dblEmpiricalVariance;
  306.     }

  308.     /**
  309.      * Retrieve the Population Variance
  310.      * 
  311.      * @return The Population Variance
  312.      * 
  313.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  314.      */

  316.     public double populationVariance()
  317.         throws java.lang.Exception
  318.     {
  319.         return null == _distPopulation ? java.lang.Double.NaN : _distPopulation.variance();
  320.     }

  322.     /**
  323.      * Retrieve the Sequence Positiveness Flag
  324.      * 
  325.      * @return TRUE - The Sequence is Positiveness
  326.      */

  328.     public boolean isPositive()
  329.     {
  330.         return _bIsPositive;
  331.     }

  333.     /**
  334.      * Retrieve the Input Sequence
  335.      * 
  336.      * @return The Input Sequence
  337.      */

  339.     public double[] sequence()
  340.     {
  341.         return _adblSequence;
  342.     }

  344.     /**
  345.      * Retrieve the Markov Upper Limiting Probability Bound for the Specified Level:
  346.      *  - P (X gte t) lte E[f(X)] / f(t)
  347.      * 
  348.      * @param dblLevel The Specified Level
  349.      * @param auNonDecreasing The Non-decreasing Bounding Transformer Function
  350.      * 
  351.      * @return The Markov Upper Limiting Probability Bound for the Specified Level
  352.      * 
  353.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  354.      */

  356.     public double markovUpperProbabilityBound (
  357.         final double dblLevel,
  358.         final org.drip.function.definition.R1ToR1 auNonDecreasing)
  359.         throws java.lang.Exception
  360.     {
  361.         if (!isPositive() || !org.drip.numerical.common.NumberUtil.IsValid (dblLevel) || dblLevel <= 0.)
  362.             throw new java.lang.Exception
  363.                 ("SingleSequenceAgnosticMetrics::markovUpperProbabilityBound => Invalid Inputs");

  365.         double dblPopulationMean = populationMean();

  367.         double dblUpperProbabilityBound = (org.drip.numerical.common.NumberUtil.IsValid (dblPopulationMean) ?
  368.             dblPopulationMean : _dblEmpiricalExpectation) / dblLevel;

  370.         if (null != auNonDecreasing) {
  371.             SingleSequenceAgnosticMetrics smFunction = functionSequenceMetrics (auNonDecreasing);

  373.             if (null == smFunction)
  374.                 throw new java.lang.Exception
  375.                     ("SingleSequenceAgnosticMetrics::markovUpperProbabilityBound => Cannot generate Function Sequence Metrics");

  377.             dblUpperProbabilityBound = smFunction.empiricalExpectation() / auNonDecreasing.evaluate
  378.                 (dblLevel);
  379.         }

  381.         return dblUpperProbabilityBound < 1. ? dblUpperProbabilityBound : 1.;
  382.     }

  384.     /**
  385.      * Retrieve the Mean Departure Bounds Using the Chebyshev's Inequality
  386.      * 
  387.      * @param dblLevel The Level at which the Departure is sought
  388.      * 
  389.      * @return The Mean Departure Bounds Instance
  390.      */

  392.     public org.drip.sequence.metrics.PivotedDepartureBounds chebyshevBound (
  393.         final double dblLevel)
  394.     {
  395.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblLevel) || dblLevel <= 0.) return null;

  397.         try {
  398.             double dblPopulationVariance = populationVariance();

  400.             double dblMeanDepartureBound = (org.drip.numerical.common.NumberUtil.IsValid (dblPopulationVariance) ?
  401.                 dblPopulationVariance : _dblEmpiricalVariance) / (dblLevel * dblLevel);

  403.             dblMeanDepartureBound = dblMeanDepartureBound < 1. ? dblMeanDepartureBound : 1.;

  405.             return new org.drip.sequence.metrics.PivotedDepartureBounds
  406.                 (org.drip.sequence.metrics.PivotedDepartureBounds.PIVOT_ANCHOR_TYPE_MEAN, java.lang.Double.NaN,
  407.                     dblMeanDepartureBound, dblMeanDepartureBound);
  408.         } catch (java.lang.Exception e) {
  409.             e.printStackTrace();
  410.         }

  412.         return null;
  413.     }

  415.     /**
  416.      * Retrieve the Mean Departure Bounds Using the Central Moment Bounding Inequality
  417.      * 
  418.      * @param dblLevel The Level at which the Departure is sought
  419.      * @param iMoment The Moment Bound sought
  420.      * 
  421.      * @return The Mean Departure Bounds Instance
  422.      */

  424.     public org.drip.sequence.metrics.PivotedDepartureBounds centralMomentBound (
  425.         final double dblLevel,
  426.         final int iMoment)
  427.     {
  428.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblLevel) || dblLevel <= 0.) return null;

  430.         try {
  431.             double dblMeanDepartureBound = empiricalCentralMoment (iMoment, true) / java.lang.Math.pow
  432.                 (dblLevel, iMoment);

  434.             dblMeanDepartureBound = dblMeanDepartureBound < 1. ? dblMeanDepartureBound : 1.;

  436.             return new org.drip.sequence.metrics.PivotedDepartureBounds
  437.                 (org.drip.sequence.metrics.PivotedDepartureBounds.PIVOT_ANCHOR_TYPE_MEAN, java.lang.Double.NaN,
  438.                     dblMeanDepartureBound, dblMeanDepartureBound);
  439.         } catch (java.lang.Exception e) {
  440.             e.printStackTrace();
  441.         }

  443.         return null;
  444.     }

  446.     /**
  447.      * Retrieve the Mean Departure Bounds Using the Chebyshev-Cantelli Inequality
  448.      * 
  449.      * @param dblLevel The Level at which the Departure is sought
  450.      * 
  451.      * @return The Mean Departure Bounds
  452.      */

  454.     public org.drip.sequence.metrics.PivotedDepartureBounds chebyshevCantelliBound (
  455.         final double dblLevel)
  456.     {
  457.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblLevel) || dblLevel <= 0.) return null;

  459.         try {
  460.             double dblPopulationVariance = populationVariance();

  462.             double dblVariance = (org.drip.numerical.common.NumberUtil.IsValid (dblPopulationVariance) ?
  463.                 dblPopulationVariance : _dblEmpiricalVariance);

  465.             return new org.drip.sequence.metrics.PivotedDepartureBounds
  466.                 (org.drip.sequence.metrics.PivotedDepartureBounds.PIVOT_ANCHOR_TYPE_MEAN, java.lang.Double.NaN,
  467.                     java.lang.Double.NaN, dblVariance / (dblVariance + dblLevel * dblLevel));
  468.         } catch (java.lang.Exception e) {
  469.             e.printStackTrace();
  470.         }

  472.         return null;
  473.     }

  475.     /**
  476.      * Retrieve the Chebyshev's Association Joint Expectation Bound
  477.      * 
  478.      * @param au1 Function 1 Operating On Sequence 1
  479.      * @param bNonDecreasing1 TRUE - Function 1 is non-decreasing
  480.      * @param au2 Function 2 Operating On Sequence 2
  481.      * @param bNonDecreasing2 TRUE - Function 2 is non-decreasing
  482.      * 
  483.      * @return The Chebyshev's Association Joint Expectation Bound
  484.      */

  486.     public org.drip.sequence.metrics.PivotedDepartureBounds chebyshevAssociationBound (
  487.         final org.drip.function.definition.R1ToR1 au1,
  488.         final boolean bNonDecreasing1,
  489.         final org.drip.function.definition.R1ToR1 au2,
  490.         final boolean bNonDecreasing2)
  491.     {
  492.         if (null == au1 || null == au2) return null;

  494.         double dblBound = functionSequenceMetrics (au1).empiricalExpectation() * functionSequenceMetrics
  495.             (au2).empiricalExpectation();

  497.         dblBound = dblBound < 1. ? dblBound : 1.;

  499.         if (bNonDecreasing1 == bNonDecreasing2) {
  500.             try {
  501.                 return new org.drip.sequence.metrics.PivotedDepartureBounds
  502.                     (org.drip.sequence.metrics.PivotedDepartureBounds.PIVOT_ANCHOR_TYPE_CUSTOM, 0.,
  503.                         dblBound, java.lang.Double.NaN);
  504.             } catch (java.lang.Exception e) {
  505.                 e.printStackTrace();
  506.             }

  508.             return null;
  509.         }

  511.         try {
  512.             return new org.drip.sequence.metrics.PivotedDepartureBounds
  513.                 (org.drip.sequence.metrics.PivotedDepartureBounds.PIVOT_ANCHOR_TYPE_CUSTOM, 0.,
  514.                     java.lang.Double.NaN, dblBound);
  515.         } catch (java.lang.Exception e) {
  516.             e.printStackTrace();
  517.         }

  519.         return null;
  520.     }

  522.     /**
  523.      * Estimate Mean Departure Bounds of the Average using the Weak Law of Large Numbers
  524.      * 
  525.      * @param dblLevel The Level at which the Departure is sought
  526.      * 
  527.      * @return The Mean Departure Bounds
  528.      */

  530.     public org.drip.sequence.metrics.PivotedDepartureBounds weakLawAverageBounds (
  531.         final double dblLevel)
  532.     {
  533.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblLevel) || dblLevel <= 0.) return null;

  535.         try {
  536.             double dblPopulationVariance = populationVariance();

  538.             double dblVariance = (org.drip.numerical.common.NumberUtil.IsValid (dblPopulationVariance) ?
  539.                 dblPopulationVariance : _dblEmpiricalVariance);

  541.             double dblBound = dblVariance / (_adblSequence.length * dblLevel * dblLevel);
  542.             dblBound = dblBound < 1. ? dblBound : 1.;

  544.             return new org.drip.sequence.metrics.PivotedDepartureBounds
  545.                 (org.drip.sequence.metrics.PivotedDepartureBounds.PIVOT_ANCHOR_TYPE_MEAN,
  546.                     java.lang.Double.NaN, dblBound, dblBound);
  547.         } catch (java.lang.Exception e) {
  548.             e.printStackTrace();
  549.         }

  551.         return null;
  552.     }
  553. }
Created with JaCoCo 0.7.9.201702052155