R1Central.java

  1. package org.drip.measure.chisquare;

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

  77. /**
  78.  * <i>R1Central</i> implements the Probability Density Function for the R<sup>1</sup> Central Chi-Square
  79.  *  Distribution. The References are:
  80.  * 
  81.  * <br><br>
  82.  *  <ul>
  83.  *      <li>
  84.  *          Abramowitz, M., and I. A. Stegun (2007): <i>Handbook of Mathematics Functions</i> <b>Dover Book
  85.  *              on Mathematics</b>
  86.  *      </li>
  87.  *      <li>
  88.  *          Backstrom, T., and J. Fischer (2018): Fast Randomization for Distributed Low Bit-rate Coding of
  89.  *              Speech and Audio <i>IEEE/ACM Transactions on Audio, Speech, and Language Processing</i> <b>26
  90.  *              (1)</b> 19-30
  91.  *      </li>
  92.  *      <li>
  93.  *          Chi-Squared Distribution (2019): Chi-Squared Function
  94.  *              https://en.wikipedia.org/wiki/Chi-squared_distribution
  95.  *      </li>
  96.  *      <li>
  97.  *          Johnson, N. L., S. Kotz, and N. Balakrishnan (1994): <i>Continuous Univariate Distributions
  98.  *              2<sup>nd</sup> Edition</i> <b>John Wiley and Sons</b>
  99.  *      </li>
  100.  *      <li>
  101.  *          National Institute of Standards and Technology (2019): Chi-Squared Distribution
  102.  *              https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
  103.  *      </li>
  104.  *  </ul>
  105.  *
  106.  *  <br><br>
  107.  *  <ul>
  108.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  109.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalAnalysisLibrary.md">Numerical Analysis Library</a></li>
  110.  *      <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>
  111.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/chisquare/README.md">Chi-Square Distribution Implementation/Properties</a></li>
  112.  *  </ul>
  113.  *
  114.  * @author Lakshmi Krishnamurthy
  115.  */

  117. public class R1Central extends org.drip.measure.continuous.R1Univariate
  118. {
  119.     private double _degreesOfFreedom = -1;
  120.     private double _cdfScaler = java.lang.Double.NaN;
  121.     private double _normalizer = java.lang.Double.NaN;
  122.     private org.drip.function.definition.R1ToR1 _gammaEstimator = null;
  123.     private org.drip.function.definition.R1ToR1 _digammaEstimator = null;
  124.     private org.drip.function.definition.R2ToR1 _lowerIncompleteGammaEstimator = null;

  126.     /**
  127.      * Generate a Consolidated Chi-squared Distribution from Independent Component Distributions
  128.      * 
  129.      * @param chiSquaredDistributionArray Independent Component Distribution Array
  130.      * 
  131.      * @return Consolidated Chi-squared Distribution
  132.      */

  134.     public static final R1Central FromIndependentChiSquared (
  135.         final org.drip.measure.chisquare.R1Central[] chiSquaredDistributionArray)
  136.     {
  137.         if (null == chiSquaredDistributionArray || 0 == chiSquaredDistributionArray.length)
  138.         {
  139.             return null;
  140.         }

  142.         double degreesOfFreedom = 0;

  144.         for (org.drip.measure.chisquare.R1Central chiSquaredDistribution :
  145.             chiSquaredDistributionArray)
  146.         {
  147.             if (null == chiSquaredDistribution)
  148.             {
  149.                 return null;
  150.             }

  152.             degreesOfFreedom = degreesOfFreedom + chiSquaredDistribution.degreesOfFreedom();
  153.         }

  155.         try
  156.         {
  157.             return new R1Central (
  158.                 degreesOfFreedom,
  159.                 chiSquaredDistributionArray[0].gammaEstimator(),
  160.                 chiSquaredDistributionArray[0].digammaEstimator(),
  161.                 chiSquaredDistributionArray[0].lowerIncompleteGammaEstimator()
  162.             );
  163.         }
  164.         catch (java.lang.Exception e)
  165.         {
  166.             e.printStackTrace();
  167.         }

  169.         return null;
  170.     }

  172.     /**
  173.      * R1Central Constructor
  174.      * 
  175.      * @param degreesOfFreedom Degrees of Freedom
  176.      * @param gammaEstimator Gamma Estimator
  177.      * @param digammaEstimator Digamma Estimator
  178.      * @param lowerIncompleteGammaEstimator Lower Incomplete Gamma Estimator
  179.      * 
  180.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  181.      */

  183.     public R1Central (
  184.         final double degreesOfFreedom,
  185.         final org.drip.function.definition.R1ToR1 gammaEstimator,
  186.         final org.drip.function.definition.R1ToR1 digammaEstimator,
  187.         final org.drip.function.definition.R2ToR1 lowerIncompleteGammaEstimator)
  188.         throws java.lang.Exception
  189.     {
  190.         if (!org.drip.numerical.common.NumberUtil.IsValid (
  191.                 _degreesOfFreedom = degreesOfFreedom
  192.             ) || 0. >= _degreesOfFreedom ||
  193.             null == (_gammaEstimator = gammaEstimator) ||
  194.             null == (_digammaEstimator = digammaEstimator) ||
  195.             null == (_lowerIncompleteGammaEstimator = lowerIncompleteGammaEstimator))
  196.         {
  197.             throw new java.lang.Exception ("R1Central Constructor => Invalid Inputs");
  198.         }

  200.         double halfDOF = 0.5 * _degreesOfFreedom;

  202.         _normalizer = (_cdfScaler = 1. / _gammaEstimator.evaluate (halfDOF)) * java.lang.Math.pow (
  203.             2.,
  204.             -1. * halfDOF
  205.         );
  206.     }

  208.     /**
  209.      * Retrieve the Degrees of Freedom
  210.      * 
  211.      * @return The Degrees of Freedom
  212.      */

  214.     public double degreesOfFreedom()
  215.     {
  216.         return _degreesOfFreedom;
  217.     }

  219.     /**
  220.      * Retrieve the Gamma Estimator
  221.      * 
  222.      * @return Gamma Estimator
  223.      */

  225.     public org.drip.function.definition.R1ToR1 gammaEstimator()
  226.     {
  227.         return _gammaEstimator;
  228.     }

  230.     /**
  231.      * Retrieve the Digamma Estimator
  232.      * 
  233.      * @return Digamma Estimator
  234.      */

  236.     public org.drip.function.definition.R1ToR1 digammaEstimator()
  237.     {
  238.         return _digammaEstimator;
  239.     }

  241.     /**
  242.      * Retrieve the Lower Incomplete Gamma Estimator
  243.      * 
  244.      * @return Lower Incomplete Gamma Estimator
  245.      */

  247.     public org.drip.function.definition.R2ToR1 lowerIncompleteGammaEstimator()
  248.     {
  249.         return _lowerIncompleteGammaEstimator;
  250.     }

  252.     @Override public double[] support()
  253.     {
  254.         return new double[]
  255.         {
  256.             0.,
  257.             java.lang.Double.POSITIVE_INFINITY
  258.         };
  259.     }

  261.     @Override public double density (
  262.         final double t)
  263.         throws java.lang.Exception
  264.     {
  265.         if (!supported (t))
  266.         {
  267.             throw new java.lang.Exception ("R1Central::density => Variate not in Range");
  268.         }

  270.         return _normalizer * java.lang.Math.pow (
  271.             t,
  272.             0.5 * _degreesOfFreedom - 1.
  273.         ) * java.lang.Math.exp (-0.5 * t);
  274.     }

  276.     @Override public double cumulative (
  277.         final double t)
  278.         throws java.lang.Exception
  279.     {
  280.         if (!supported (t))
  281.         {
  282.             throw new java.lang.Exception ("R1Central::cumulative => Invalid Inputs");
  283.         }

  285.         return _cdfScaler * _lowerIncompleteGammaEstimator.evaluate (
  286.             0.5 * _degreesOfFreedom,
  287.             0.5 * t
  288.         );
  289.     }

  291.     @Override public double mean()
  292.         throws java.lang.Exception
  293.     {
  294.         return _degreesOfFreedom;
  295.     }

  297.     @Override public double median()
  298.         throws java.lang.Exception
  299.     {
  300.         double oneMinus_twoOver_9dof__ = 1. - (2. / (9. * _degreesOfFreedom));

  302.         return _degreesOfFreedom * oneMinus_twoOver_9dof__ * oneMinus_twoOver_9dof__ *
  303.             oneMinus_twoOver_9dof__;
  304.     }

  306.     @Override public double mode()
  307.         throws java.lang.Exception
  308.     {
  309.         return java.lang.Math.max (
  310.             _degreesOfFreedom - 2.,
  311.             0.
  312.         );
  313.     }

  315.     @Override public double variance()
  316.         throws java.lang.Exception
  317.     {
  318.         return 2. * _degreesOfFreedom;
  319.     }

  321.     @Override public double skewness()
  322.         throws java.lang.Exception
  323.     {
  324.         return java.lang.Math.sqrt (8. / _degreesOfFreedom);
  325.     }

  327.     @Override public double excessKurtosis()
  328.         throws java.lang.Exception
  329.     {
  330.         return 12. / _degreesOfFreedom;
  331.     }

  333.     @Override public double differentialEntropy()
  334.         throws java.lang.Exception
  335.     {
  336.         double halfDOF = 0.5 * _degreesOfFreedom;

  338.         return halfDOF + java.lang.Math.log (2. * _gammaEstimator.evaluate (halfDOF)) +
  339.             (1. - halfDOF) * _digammaEstimator.evaluate (halfDOF);
  340.     }

  342.     @Override public org.drip.function.definition.R1ToR1 momentGeneratingFunction()
  343.     {
  344.         return new org.drip.function.definition.R1ToR1 (null)
  345.         {
  346.             @Override public double evaluate (
  347.                 final double t)
  348.                 throws java.lang.Exception
  349.             {
  350.                 if (!org.drip.numerical.common.NumberUtil.IsValid (t) || t > 0.5)
  351.                 {
  352.                     throw new java.lang.Exception
  353.                         ("R1Central::momentGeneratingFunction::evaluate => Invalid Input");
  354.                 }

  356.                 return java.lang.Math.pow (
  357.                     1. - 2. * t,
  358.                     -0.5 * _degreesOfFreedom
  359.                 );
  360.             }
  361.         };
  362.     }

  364.     @Override public org.drip.function.definition.R1ToR1 probabilityGeneratingFunction()
  365.     {
  366.         return new org.drip.function.definition.R1ToR1 (null)
  367.         {
  368.             @Override public double evaluate (
  369.                 final double t)
  370.                 throws java.lang.Exception
  371.             {
  372.                 if (!org.drip.numerical.common.NumberUtil.IsValid (t) ||
  373.                     t <= 0. || t > java.lang.Math.sqrt (java.lang.Math.E))
  374.                 {
  375.                     throw new java.lang.Exception
  376.                         ("R1Central::probabilityGeneratingFunction::evaluate => Invalid Input");
  377.                 }

  379.                 return java.lang.Math.pow (
  380.                     1. - 2. * java.lang.Math.log (t),
  381.                     -0.5 * _degreesOfFreedom
  382.                 );
  383.             }
  384.         };
  385.     }

  387.     @Override public double random()
  388.         throws java.lang.Exception
  389.     {
  390.         double sumOfStandardNormalSquares = 0.;

  392.         for (int drawIndex = 0; drawIndex < _degreesOfFreedom; ++drawIndex)
  393.         {
  394.             double randomStandardNormal = org.drip.measure.gaussian.NormalQuadrature.InverseCDF
  395.                 (java.lang.Math.random());

  397.             sumOfStandardNormalSquares = sumOfStandardNormalSquares +
  398.                 randomStandardNormal * randomStandardNormal;
  399.         }

  401.         return sumOfStandardNormalSquares;
  402.     }

  404.     /**
  405.      * Retrieve the Normalizer
  406.      * 
  407.      * @return Normalizer
  408.      */

  410.     public double normalizer()
  411.     {
  412.         return _normalizer;
  413.     }

  415.     /**
  416.      * Retrieve the CDF Scaler
  417.      * 
  418.      * @return CDF Scaler
  419.      */

  421.     public double cdfScaler()
  422.     {
  423.         return _cdfScaler;
  424.     }

  426.     /**
  427.      * Compute the Chernoff Upper Bound
  428.      * 
  429.      * @param x A
  430.      * 
  431.      * @return The Chernoff Upper Bound
  432.      * 
  433.      * @throws java.lang.Exception Thrown if the Chernoff Upper Bound cannot be calculated
  434.      */

  436.     public double chernoffBound (
  437.         final double x)
  438.         throws java.lang.Exception
  439.     {
  440.         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x)
  441.         {
  442.             throw new java.lang.Exception ("R1Central::chernoffBound => Invalid Inputs");
  443.         }

  445.         double z = x / _degreesOfFreedom;

  447.         if (1. == z)
  448.         {
  449.             throw new java.lang.Exception ("R1Central::chernoffBound => Invalid Inputs");
  450.         }

  452.         double _zExponent_OneMinusZ__powerHalfDegreesOfFreedom = java.lang.Math.pow (
  453.             z * java.lang.Math.exp (1. - z),
  454.             0.5 * _degreesOfFreedom
  455.         );

  457.         return 1. > z ? _zExponent_OneMinusZ__powerHalfDegreesOfFreedom : 1. -
  458.             _zExponent_OneMinusZ__powerHalfDegreesOfFreedom;
  459.     }

  461.     /**
  462.      * Compute the Non-central Moment about Zero
  463.      * 
  464.      * @param m Non-central Moment Index
  465.      * 
  466.      * @return The Non-central Moment about Zero
  467.      * 
  468.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  469.      */

  471.     public double nonCentralMoment (
  472.         final int m)
  473.         throws java.lang.Exception
  474.     {
  475.         if (0 > m)
  476.         {
  477.             throw new java.lang.Exception ("R1Central::nonCentralMoment => Invalid Inputs");
  478.         }

  480.         double halfDOF = 0.5 * _degreesOfFreedom;

  482.         return java.lang.Math.pow (
  483.             2.,
  484.             m
  485.         ) * _gammaEstimator.evaluate (m + halfDOF) / _gammaEstimator.evaluate (halfDOF);
  486.     }

  488.     /**
  489.      * Compute the Cumulant
  490.      * 
  491.      * @param n Cumulant Index
  492.      * 
  493.      * @return The Cumulant
  494.      * 
  495.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  496.      */

  498.     public double cumulant (
  499.         final int n)
  500.         throws java.lang.Exception
  501.     {
  502.         if (0 > n)
  503.         {
  504.             throw new java.lang.Exception ("R1Central::cumulant => Invalid Inputs");
  505.         }

  507.         return _degreesOfFreedom * java.lang.Math.pow (
  508.             2.,
  509.             n - 1.
  510.         ) * _gammaEstimator.evaluate (n);
  511.     }

  513.     /**
  514.      * Retrieve the Central Limit Theorem Equivalent Normal Distribution Proxy
  515.      * 
  516.      * @return The Central Limit Theorem Equivalent Normal Distribution Proxy
  517.      */

  519.     public org.drip.measure.gaussian.R1UnivariateNormal cltProxy()
  520.     {
  521.         try
  522.         {
  523.             return new org.drip.measure.gaussian.R1UnivariateNormal (
  524.                 _degreesOfFreedom,
  525.                 2. * _degreesOfFreedom
  526.             );
  527.         }
  528.         catch (java.lang.Exception e)
  529.         {
  530.             e.printStackTrace();
  531.         }

  533.         return null;
  534.     }

  536.     /**
  537.      * Indicate if the Current Distribution is a Valid Proxy as a CLT
  538.      * 
  539.      * @return TRUE - The Current Distribution is a Valid Proxy as a CLT
  540.      */

  542.     public boolean validCLTProxy()
  543.     {
  544.         return 50. <= _degreesOfFreedom;
  545.     }

  547.     /**
  548.      * Generate a Gamma-distribution off of the Scaled Chi-Square Distribution
  549.      * 
  550.      * @param scale The Scale
  551.      * 
  552.      * @return The Gamma Distribution
  553.      */

  555.     public org.drip.measure.gamma.R1ShapeScaleDistribution gammaDistribution (
  556.         final double scale)
  557.     {
  558.         try
  559.         {
  560.             return new org.drip.measure.gamma.R1ShapeScaleDistribution (
  561.                 new org.drip.measure.gamma.ShapeScaleParameters (
  562.                     0.5 * _degreesOfFreedom,
  563.                     2. * scale
  564.                 ),
  565.                 _gammaEstimator,
  566.                 _digammaEstimator,
  567.                 _lowerIncompleteGammaEstimator
  568.             );
  569.         }
  570.         catch (java.lang.Exception e)
  571.         {
  572.             e.printStackTrace();
  573.         }

  575.         return null;
  576.     }

  578.     /**
  579.      * Generate Logarithm Proxy Based Random Number - Proxy to Univariate Normal Distribution
  580.      * 
  581.      * @return Logarithm Proxy Based Random Number - Proxy to Univariate Normal Distribution
  582.      * 
  583.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  584.      */

  586.     public double randomLogProxy()
  587.         throws java.lang.Exception
  588.     {
  589.         return java.lang.Math.log (_degreesOfFreedom);
  590.     }

  592.     /**
  593.      * Generate CLT Proxy Based Random Number - Proxy to Univariate Normal Distribution
  594.      * 
  595.      * @return CLT Proxy Based Random Number - Proxy to Univariate Normal Distribution
  596.      * 
  597.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  598.      */

  600.     public double randomCLTProxy()
  601.         throws java.lang.Exception
  602.     {
  603.         return (random() - _degreesOfFreedom) / java.lang.Math.sqrt (2. * _degreesOfFreedom);
  604.     }

  606.     /**
  607.      * Generate Fisher Proxy Random Number - Proxy to Univariate Normal Distribution
  608.      * 
  609.      * @return Fisher Proxy Random Number - Proxy to Univariate Normal Distribution
  610.      * 
  611.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  612.      */

  614.     public double randomFisherProxy()
  615.         throws java.lang.Exception
  616.     {
  617.         return java.lang.Math.sqrt (2. * random());
  618.     }

  620.     /**
  621.      * Generate Wilson-Hilferty Proxy Random Number - Proxy to Univariate Normal Distribution
  622.      * 
  623.      * @return Wilson-Hilferty Proxy Random Number - Proxy to Univariate Normal Distribution
  624.      * 
  625.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  626.      */

  628.     public double randomWilsonHilferty()
  629.         throws java.lang.Exception
  630.     {
  631.         return java.lang.Math.pow (
  632.             random() / _degreesOfFreedom,
  633.             1. / 3.
  634.         );
  635.     }

  637.     /**
  638.      * Generate Gamma Distributed Random Number
  639.      * 
  640.      * @param c The Scale Parameter
  641.      * 
  642.      * @return Gamma Distributed Random Number
  643.      * 
  644.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  645.      */

  647.     public double randomGamma (
  648.         final double c)
  649.         throws java.lang.Exception
  650.     {
  651.         if (!org.drip.numerical.common.NumberUtil.IsValid (c) || 0. >= c)
  652.         {
  653.             throw new java.lang.Exception ("R1Central::randomGamma => Invalid Inputs");
  654.         }

  656.         return random() * c;
  657.     }

  659.     /**
  660.      * Generate the Chi Distributed Random Number
  661.      * 
  662.      * @return Chi Distributed Random Number
  663.      * 
  664.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  665.      */

  667.     public double randomChi()
  668.         throws java.lang.Exception
  669.     {
  670.         return java.lang.Math.sqrt (random());
  671.     }

  673.     /**
  674.      * Generate Exponential (0.5) Distributed Random Number
  675.      * 
  676.      * @return Exponential (0.5) Distributed Random Number
  677.      * 
  678.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  679.      */

  681.     public double randomExponentialHalf()
  682.         throws java.lang.Exception
  683.     {
  684.         if (2. != _degreesOfFreedom)
  685.         {
  686.             throw new java.lang.Exception ("R1Central::randomExponentialHalf => Invalid Inputs");
  687.         }

  689.         return random();
  690.     }

  692.     /**
  693.      * Generate Rayleigh (1) Distributed Random Number
  694.      * 
  695.      * @return Rayleigh (1) Distributed Random Number
  696.      * 
  697.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  698.      */

  700.     public double randomRayleigh1()
  701.         throws java.lang.Exception
  702.     {
  703.         if (2. != _degreesOfFreedom)
  704.         {
  705.             throw new java.lang.Exception ("R1Central::randomRayleigh1 => Invalid Inputs");
  706.         }

  708.         return random();
  709.     }

  711.     /**
  712.      * Generate Maxwell (1) Distributed Random Number
  713.      * 
  714.      * @return Maxwell (1) Distributed Random Number
  715.      * 
  716.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  717.      */

  719.     public double randomMaxwell1()
  720.         throws java.lang.Exception
  721.     {
  722.         if (3. != _degreesOfFreedom)
  723.         {
  724.             throw new java.lang.Exception ("R1Central::randomMaxwell1 => Invalid Inputs");
  725.         }

  727.         return random();
  728.     }
  729. }
Created with JaCoCo 0.7.9.201702052155