SequenceGenerator.java

  1. package org.drip.measure.discrete;

  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>SequenceGenerator</i> generates the specified Univariate Sequence of the Given Distribution Type.
  83.  *
  84.  * <br><br>
  85.  *  <ul>
  86.  *      <li>
  87.  *          Backstrom, T., and J. Fischer (2018): Fast Randomization for Distributed Low Bit-rate Coding of
  88.  *              Speech and Audio <i>IEEE/ACM Transactions on Audio, Speech, and Language Processing</i> <b>26
  89.  *              (1)</b> 19-30
  90.  *      </li>
  91.  *      <li>
  92.  *          Chi-Squared Distribution (2019): Chi-Squared Function
  93.  *              https://en.wikipedia.org/wiki/Chi-squared_distribution
  94.  *      </li>
  95.  *      <li>
  96.  *          Johnson, N. L., S. Klotz, and N. Balakrishnan (1994): <i>Continuous Univariate Distributions
  97.  *              <b>1</b> 2<sup>nd</sup> Edition</i> <b>John Wiley and Sons</b>
  98.  *      </li>
  99.  *      <li>
  100.  *          Lancaster, H, O. (1969): <i>The Chi-Squared Distribution</i> <b>Wiley</b>
  101.  *      </li>
  102.  *      <li>
  103.  *          Pillai, N. S. (1026): An Unexpected Encounter with Cauchy and Levy <i>Annals of Statistics</i>
  104.  *              <b>44 (5)</b> 2089-2097
  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/NumericalAnalysisLibrary.md">Numerical Analysis Library</a></li>
  112.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/README.md">R<sup>d</sup> Continuous/Discrete Probability Measures</a></li>
  113.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/discrete/README.md">Antithetic, Quadratically Re-sampled, De-biased Distribution</a></li>
  114.  *  </ul>
  115.  *
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class SequenceGenerator
  120. {

  122.     /**
  123.      * Generate a Sequence of Uniform Random Numbers
  124.      * 
  125.      * @param iCount The Count in the Sequence
  126.      * 
  127.      * @return The Sequence of Uniform Random Numbers
  128.      */

  130.     public static final double[] Uniform (
  131.         final int iCount)
  132.     {
  133.         if (0 >= iCount) return null;

  135.         double[] adblRandom = new double[iCount];

  137.         for (int i = 0; i < iCount; ++i)
  138.             adblRandom[i] = java.lang.Math.random();

  140.         return adblRandom;
  141.     }

  143.     /**
  144.      * Generate a Sequence of Gaussian Random Numbers
  145.      * 
  146.      * @param iCount The Count in the Sequence
  147.      * 
  148.      * @return The Sequence of Gaussian Random Numbers
  149.      */

  151.     public static final double[] Gaussian (
  152.         final int iCount)
  153.     {
  154.         if (0 >= iCount) return null;

  156.         double[] adblRandom = new double[iCount];

  158.         for (int i = 0; i < iCount; ++i) {
  159.             try {
  160.                 adblRandom[i] = org.drip.measure.gaussian.NormalQuadrature.Random();
  161.             } catch (java.lang.Exception e) {
  162.                 e.printStackTrace();

  164.                 return null;
  165.             }
  166.         }

  168.         return adblRandom;
  169.     }

  171.     /**
  172.      * Generate a Sequence of Log Normal Random Numbers
  173.      * 
  174.      * @param iCount The Count in the Sequence
  175.      * 
  176.      * @return The Sequence of Log Normal Random Numbers
  177.      */

  179.     public static final double[] LogNormal (
  180.         final int iCount)
  181.     {
  182.         if (0 >= iCount) return null;

  184.         double[] adblRandom = new double[iCount];

  186.         double dblNormalizer = 1. / java.lang.Math.sqrt (java.lang.Math.E);

  188.         for (int i = 0; i < iCount; ++i) {
  189.             try {
  190.                 adblRandom[i] = java.lang.Math.exp (org.drip.measure.gaussian.NormalQuadrature.Random()) *
  191.                     dblNormalizer;
  192.             } catch (java.lang.Exception e) {
  193.                 e.printStackTrace();

  195.                 return null;
  196.             }
  197.         }

  199.         return adblRandom;
  200.     }

  202.     /**
  203.      * Generate a Sequence of R^d Correlated Gaussian Random Numbers
  204.      * 
  205.      * @param iCount The Count in the Sequence
  206.      * @param aadblCorrelation The Correlation Matrix
  207.      * 
  208.      * @return The Sequence of R^d Correlated Gaussian Random Numbers
  209.      */

  211.     public static final double[][] GaussianJoint (
  212.         final int iCount,
  213.         final double[][] aadblCorrelation)
  214.     {
  215.         if (0 >= iCount) return null;

  217.         double[][] aadblCholesky = org.drip.numerical.linearalgebra.Matrix.CholeskyBanachiewiczFactorization
  218.             (aadblCorrelation);

  220.         if (null == aadblCholesky) return null;

  222.         int iDimension = aadblCholesky.length;
  223.         double[][] aadblRandom = new double[iCount][];

  225.         for (int k = 0; k < iCount; ++k) {
  226.             double[] adblUncorrelatedRandom = Gaussian (iDimension);

  228.             if (null == adblUncorrelatedRandom || iDimension != adblUncorrelatedRandom.length) return null;

  230.             double[] adblCorrelatedRandom = new double[iDimension];

  232.             for (int i = 0; i < iDimension; ++i) {
  233.                 adblCorrelatedRandom[i] = 0.;

  235.                 for (int j = 0; j < iDimension; ++j)
  236.                     adblCorrelatedRandom[i] += aadblCholesky[i][j] * adblUncorrelatedRandom[j];
  237.             }

  239.             aadblRandom[k] = adblCorrelatedRandom;
  240.         }

  242.         return aadblRandom;
  243.     }

  245.     /**
  246.      * Generate an Array of Chi-Squared Distributed Random Numbers
  247.      * 
  248.      * @param count Array Count
  249.      * @param degreesOfFreedom Degrees of Freedom
  250.      * 
  251.      * @return Array of Chi-Squared Distributed Random Numbers
  252.      */

  254.     public static final double[] ChiSquared (
  255.         final int count,
  256.         final int degreesOfFreedom)
  257.     {
  258.         if (0 >= degreesOfFreedom)
  259.         {
  260.             return null;
  261.         }

  263.         double[] chiSquaredArray = new double[count];

  265.         for (int index = 0; index < count; ++index)
  266.         {
  267.             double sumOfStandardNormalSquares = 0.;

  269.             for (int drawIndex = 0; drawIndex < degreesOfFreedom; ++drawIndex)
  270.             {
  271.                 try
  272.                 {
  273.                     double randomStandardNormal = org.drip.measure.gaussian.NormalQuadrature.InverseCDF
  274.                         (java.lang.Math.random());

  276.                     sumOfStandardNormalSquares = sumOfStandardNormalSquares +
  277.                         randomStandardNormal * randomStandardNormal;
  278.                 }
  279.                 catch (java.lang.Exception e)
  280.                 {
  281.                     e.printStackTrace();

  283.                     return null;
  284.                 }
  285.             }

  287.             chiSquaredArray[index] = sumOfStandardNormalSquares;
  288.         }

  290.         return chiSquaredArray;
  291.     }

  293.     /**
  294.      * Generate an Array of Scaled Gamma Distributed Random Numbers
  295.      * 
  296.      * @param count Array Count
  297.      * @param degreesOfFreedom Degrees of Freedom
  298.      * @param scale Scale Parameter
  299.      * 
  300.      * @return Array of Scaled Gamma Distributed Random Numbers
  301.      */

  303.     public static final double[] ScaledGamma (
  304.         final int count,
  305.         final int degreesOfFreedom,
  306.         final double scale)
  307.     {
  308.         if (!org.drip.numerical.common.NumberUtil.IsValid (scale) || 0. >= scale)
  309.         {
  310.             return null;
  311.         }

  313.         double[] chiSquaredArray =  ChiSquared (
  314.             count,
  315.             degreesOfFreedom
  316.         );

  318.         if (null == chiSquaredArray)
  319.         {
  320.             return null;
  321.         }

  323.         double[] scaledGammaArray = new double[count];

  325.         for (int index = 0; index < count; ++index)
  326.         {
  327.             scaledGammaArray[index] = scale * chiSquaredArray[index];
  328.         }

  330.         return scaledGammaArray;
  331.     }

  333.     /**
  334.      * Generate an Array of Chi Distributed Random Numbers
  335.      * 
  336.      * @param count Array Count
  337.      * @param degreesOfFreedom Degrees of Freedom
  338.      * 
  339.      * @return Array of Chi Distributed Random Numbers
  340.      */

  342.     public static final double[] Chi (
  343.         final int count,
  344.         final int degreesOfFreedom)
  345.     {
  346.         double[] chiSquaredArray =  ChiSquared (
  347.             count,
  348.             degreesOfFreedom
  349.         );

  351.         if (null == chiSquaredArray)
  352.         {
  353.             return null;
  354.         }

  356.         double[] chiArray = new double[count];

  358.         for (int index = 0; index < count; ++index)
  359.         {
  360.             chiArray[index] = java.lang.Math.sqrt (chiSquaredArray[index]);
  361.         }

  363.         return chiArray;
  364.     }

  366.     /**
  367.      * Generate an Array of Unit Scale Rayleigh Distributed Random Numbers
  368.      * 
  369.      * @param count Array Count
  370.      * 
  371.      * @return Array of Unit Scale Rayleigh Distributed Random Numbers
  372.      */

  374.     public static final double[] UnitScaleRayleigh (
  375.         final int count)
  376.     {
  377.         double[] chiSquaredArray =  ChiSquared (
  378.             count,
  379.             2
  380.         );

  382.         if (null == chiSquaredArray)
  383.         {
  384.             return null;
  385.         }

  387.         double[] unitScaleRayleighArray = new double[count];

  389.         for (int index = 0; index < count; ++index)
  390.         {
  391.             unitScaleRayleighArray[index] = java.lang.Math.sqrt (chiSquaredArray[index]);
  392.         }

  394.         return unitScaleRayleighArray;
  395.     }

  397.     /**
  398.      * Generate an Array of Unit Scale Maxwell Distributed Random Numbers
  399.      * 
  400.      * @param count Array Count
  401.      * 
  402.      * @return Array of Unit Scale Maxwell Distributed Random Numbers
  403.      */

  405.     public static final double[] UnitScaleMaxwell (
  406.         final int count)
  407.     {
  408.         double[] chiSquaredArray =  ChiSquared (
  409.             count,
  410.             3
  411.         );

  413.         if (null == chiSquaredArray)
  414.         {
  415.             return null;
  416.         }

  418.         double[] unitScaleMaxwellArray = new double[count];

  420.         for (int index = 0; index < count; ++index)
  421.         {
  422.             unitScaleMaxwellArray[index] = java.lang.Math.sqrt (chiSquaredArray[index]);
  423.         }

  425.         return unitScaleMaxwellArray;
  426.     }

  428.     /**
  429.      * Generate an Array of Inverse Chi-Squared Distributed Random Numbers
  430.      * 
  431.      * @param count Array Count
  432.      * @param degreesOfFreedom Degrees of Freedom
  433.      * 
  434.      * @return Array of Inverse Chi-Squared Distributed Random Numbers
  435.      */

  437.     public static final double[] InverseChiSquared (
  438.         final int count,
  439.         final int degreesOfFreedom)
  440.     {
  441.         double[] chiSquaredArray =  ChiSquared (
  442.             count,
  443.             degreesOfFreedom
  444.         );

  446.         if (null == chiSquaredArray)
  447.         {
  448.             return null;
  449.         }

  451.         double[] inverseChiSquaredArray = new double[count];

  453.         for (int index = 0; index < count; ++index)
  454.         {
  455.             inverseChiSquaredArray[index] = 1. / chiSquaredArray[index];
  456.         }

  458.         return inverseChiSquaredArray;
  459.     }

  461.     /**
  462.      * Generate an Array of Beta Distributed Random Numbers
  463.      * 
  464.      * @param count Array Count
  465.      * @param degreesOfFreedom1 Degrees of Freedom #1
  466.      * @param degreesOfFreedom2 Degrees of Freedom #2
  467.      * 
  468.      * @return Array of Beta Distributed Random Numbers
  469.      */

  471.     public static final double[] Beta (
  472.         final int count,
  473.         final int degreesOfFreedom1,
  474.         final int degreesOfFreedom2)
  475.     {
  476.         double[] chiSquaredArray1 = ChiSquared (
  477.             count,
  478.             degreesOfFreedom1
  479.         );

  481.         double[] chiSquaredArray2 = ChiSquared (
  482.             count,
  483.             degreesOfFreedom2
  484.         );

  486.         if (null == chiSquaredArray1 || null == chiSquaredArray2)
  487.         {
  488.             return null;
  489.         }

  491.         double[] betaArray = new double[count];

  493.         for (int index = 0; index < count; ++index)
  494.         {
  495.             betaArray[index] = chiSquaredArray1[index] / (chiSquaredArray1[index] + chiSquaredArray2[index]);
  496.         }

  498.         return betaArray;
  499.     }

  501.     /**
  502.      * Generate an Array of F Distributed Random Numbers
  503.      * 
  504.      * @param count Array Count
  505.      * @param degreesOfFreedom1 Degrees of Freedom #1
  506.      * @param degreesOfFreedom2 Degrees of Freedom #2
  507.      * 
  508.      * @return Array of F Distributed Random Numbers
  509.      */

  511.     public static final double[] F (
  512.         final int count,
  513.         final int degreesOfFreedom1,
  514.         final int degreesOfFreedom2)
  515.     {
  516.         double[] chiSquaredArray1 = ChiSquared (
  517.             count,
  518.             degreesOfFreedom1
  519.         );

  521.         double[] chiSquaredArray2 = ChiSquared (
  522.             count,
  523.             degreesOfFreedom2
  524.         );

  526.         if (null == chiSquaredArray1 || null == chiSquaredArray2)
  527.         {
  528.             return null;
  529.         }

  531.         double[] fArray = new double[count];

  533.         for (int index = 0; index < count; ++index)
  534.         {
  535.             fArray[index] = (chiSquaredArray1[index] * degreesOfFreedom2) /
  536.                 (chiSquaredArray2[index] * degreesOfFreedom1);
  537.         }

  539.         return fArray;
  540.     }

  542.     /**
  543.      * Generate a Rank-reduced Chi-Squared Distributed Array
  544.      * 
  545.      * @param count Array Count
  546.      * @param covarianceMatrix The Covariance Matrix
  547.      * 
  548.      * @return Rank-reduced Chi-Squared Distributed Array
  549.      */

  551.     public static final double[] RankReducedChiSquare (
  552.         final int count,
  553.         final double[][] covarianceMatrix)
  554.     {
  555.         double[] rankReducedChiSquare = new double[count];
  556.         org.drip.measure.gaussian.Covariance covariance = null;

  558.         try
  559.         {
  560.             covariance = new org.drip.measure.gaussian.Covariance (covarianceMatrix);
  561.         }
  562.         catch (java.lang.Exception e)
  563.         {
  564.             e.printStackTrace();

  566.             return null;
  567.         }

  569.         double[][] gaussianJointArray = GaussianJoint (
  570.             count,
  571.             covariance.correlationMatrix()
  572.         );

  574.         if (null == gaussianJointArray)
  575.         {
  576.             return null;
  577.         }

  579.         double[][] precisionMatrix = covariance.precisionMatrix();

  581.         for (int index = 0; index < count; ++index)
  582.         {
  583.             try
  584.             {
  585.                 rankReducedChiSquare[index] = org.drip.numerical.linearalgebra.Matrix.DotProduct (
  586.                     gaussianJointArray[index],
  587.                     org.drip.numerical.linearalgebra.Matrix.Product (
  588.                         precisionMatrix,
  589.                         gaussianJointArray[index]
  590.                     )
  591.                 );
  592.             }
  593.             catch (java.lang.Exception e)
  594.             {
  595.                 e.printStackTrace();

  597.                 return null;
  598.             }
  599.         }

  601.         return rankReducedChiSquare;
  602.     }


  605.     /**
  606.      * Generate a Pillai (2016) Special Chi-Squared Distributed Array
  607.      * 
  608.      * @param count Array Count
  609.      * @param covarianceMatrix The Covariance Matrix
  610.      * @param weightArray Array of Weights
  611.      * 
  612.      * @return Pillai (2016) Special Chi-Squared Distributed Array
  613.      */

  615.     public static final double[] PillaiSpecialChiSquare (
  616.         final int count,
  617.         final double[][] covarianceMatrix,
  618.         final double[] weightArray)
  619.     {
  620.         if (!org.drip.numerical.common.NumberUtil.NormalizedPositive (weightArray))
  621.         {
  622.             return null;
  623.         }

  625.         int pillaiVectorSize = weightArray.length;
  626.         double[] pillaiSpecialChiSquare = new double[count];
  627.         org.drip.measure.gaussian.Covariance covariance = null;

  629.         try
  630.         {
  631.             covariance = new org.drip.measure.gaussian.Covariance (covarianceMatrix);
  632.         }
  633.         catch (java.lang.Exception e)
  634.         {
  635.             e.printStackTrace();

  637.             return null;
  638.         }

  640.         if (pillaiVectorSize != covarianceMatrix.length)
  641.         {
  642.             return null;
  643.         }

  645.         double[][] gaussianJointArray = GaussianJoint (
  646.             count,
  647.             covariance.correlationMatrix()
  648.         );

  650.         if (null == gaussianJointArray)
  651.         {
  652.             return null;
  653.         }

  655.         for (int index = 0; index < count; ++index)
  656.         {
  657.             double[] pillaiVector = new double[pillaiVectorSize];

  659.             for (int pillaiVectorIndex = 0; pillaiVectorIndex < pillaiVectorSize; ++pillaiVectorIndex)
  660.             {
  661.                 pillaiVector[pillaiVectorIndex] = weightArray[pillaiVectorIndex] /
  662.                     gaussianJointArray[index][pillaiVectorIndex];
  663.             }

  665.             try
  666.             {
  667.                 pillaiSpecialChiSquare[index] = 1. / org.drip.numerical.linearalgebra.Matrix.DotProduct (
  668.                     pillaiVector,
  669.                     org.drip.numerical.linearalgebra.Matrix.Product (
  670.                         covarianceMatrix,
  671.                         pillaiVector
  672.                     )
  673.                 );
  674.             }
  675.             catch (java.lang.Exception e)
  676.             {
  677.                 e.printStackTrace();

  679.                 return null;
  680.             }
  681.         }

  683.         return pillaiSpecialChiSquare;
  684.     }
  685. }
Created with JaCoCo 0.7.9.201702052155