HypergeometricEqualityLemma.java

  1. package org.drip.specialfunction.property;

  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>HypergeometricEqualityLemma</i> verifies the Hyper-geometric Equality Lemma Properties. The References
  79.  * are:
  80.  * 
  81.  * <br><br>
  82.  *  <ul>
  83.  *      <li>
  84.  *          Gessel, I., and D. Stanton (1982): Strange Evaluations of Hyper-geometric Series <i>SIAM Journal
  85.  *              on Mathematical Analysis</i> <b>13 (2)</b> 295-308
  86.  *      </li>
  87.  *      <li>
  88.  *          Koepf, W (1995): Algorithms for m-fold Hyper-geometric Summation <i>Journal of Symbolic
  89.  *              Computation</i> <b>20 (4)</b> 399-417
  90.  *      </li>
  91.  *      <li>
  92.  *          Lavoie, J. L., F. Grondin, and A. K. Rathie (1996): Generalization of Whipple’s Theorem on the
  93.  *              Sum of a (_2^3)F(a,b;c;z) <i>Journal of Computational and Applied Mathematics</i> <b>72</b>
  94.  *              293-300
  95.  *      </li>
  96.  *      <li>
  97.  *          National Institute of Standards and Technology (2019): Hyper-geometric Function
  98.  *              https://dlmf.nist.gov/15
  99.  *      </li>
  100.  *      <li>
  101.  *          Wikipedia (2019): Hyper-geometric Function https://en.wikipedia.org/wiki/Hypergeometric_function
  102.  *      </li>
  103.  *  </ul>
  104.  *
  105.  *  <br><br>
  106.  *  <ul>
  107.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  108.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/FunctionAnalysisLibrary.md">Function Analysis Library</a></li>
  109.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/specialfunction/README.md">Special Function Implementation Analysis</a></li>
  110.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/specialfunction/property/README.md">Special Function Property Lemma Verifiers</a></li>
  111.  *  </ul>
  112.  *
  113.  * @author Lakshmi Krishnamurthy
  114.  */

  116. public class HypergeometricEqualityLemma
  117. {

  119.     private static final double RecursiveGaussContinedFraction (
  120.         final double a,
  121.         final double b,
  122.         final double c,
  123.         final double z,
  124.         final int termCurrent,
  125.         final int termCount)
  126.     {
  127.         if (termCurrent == termCount)
  128.         {
  129.             return 1.;
  130.         }

  132.         double gaussContinedFraction = 1. + ((b - c - termCurrent - 1.) * (a + termCurrent) /
  133.             ((c + termCurrent + 1.) * (c + termCurrent + 2.))) * z / RecursiveGaussContinedFraction (
  134.                 a,
  135.                 b,
  136.                 c,
  137.                 z,
  138.                 termCurrent + 1,
  139.                 termCount
  140.             );

  142.         return 1. + (a - c - termCurrent) * (b + termCurrent) /
  143.             ((c + termCurrent) * (c + termCurrent + 1)) * z / gaussContinedFraction;
  144.     }

  146.     /**
  147.      * Construct the First-Order Derivative Switch Verifier
  148.      * 
  149.      * @param a A
  150.      * @param b B
  151.      * 
  152.      * @return The First-Order Derivative Switch Verifier
  153.      */

  155.     public static final org.drip.function.definition.R1ToR1Property FirstOrderDerivativeSwitch (
  156.         final double a,
  157.         final double b)
  158.     {
  159.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  160.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (1000);

  162.         if (null == logBetaEstimator)
  163.         {
  164.             return null;
  165.         }

  167.         try
  168.         {
  169.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator1 =
  170.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  171.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  172.                         a,
  173.                         b,
  174.                         a + 1
  175.                     ),
  176.                     logBetaEstimator,
  177.                     10000
  178.                 );

  180.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator2 =
  181.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  182.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  183.                         b,
  184.                         a,
  185.                         a + 1
  186.                     ),
  187.                     logBetaEstimator,
  188.                     10000
  189.                 );

  191.             return new org.drip.function.definition.R1ToR1Property (
  192.                 org.drip.function.definition.R1ToR1Property.EQ,
  193.                 new org.drip.function.definition.R1ToR1 (null)
  194.                 {
  195.                     @Override public double evaluate (
  196.                         final double z)
  197.                         throws java.lang.Exception
  198.                     {
  199.                         return hypergeometricEstimator1.derivative (
  200.                             z,
  201.                             1
  202.                         );
  203.                     }
  204.                 },
  205.                 new org.drip.function.definition.R1ToR1 (null)
  206.                 {
  207.                     @Override public double evaluate (
  208.                         final double z)
  209.                         throws java.lang.Exception
  210.                     {
  211.                         return hypergeometricEstimator2.derivative (
  212.                             z,
  213.                             1
  214.                         );
  215.                     }
  216.                 },
  217.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  218.             );
  219.         }
  220.         catch (java.lang.Exception e)
  221.         {
  222.             e.printStackTrace();
  223.         }

  225.         return null;
  226.     }

  228.     /**
  229.      * Construct the First-Order Derivative Special Case Verifier
  230.      * 
  231.      * @param a A
  232.      * @param b B
  233.      * 
  234.      * @return The First-Order Derivative Special Case Verifier
  235.      */

  237.     public static final org.drip.function.definition.R1ToR1Property FirstOrderDerivativeSpecialCase (
  238.         final double a,
  239.         final double b)
  240.     {
  241.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  242.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (1000);

  244.         if (null == logBetaEstimator)
  245.         {
  246.             return null;
  247.         }

  249.         try
  250.         {
  251.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator =
  252.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  253.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  254.                         a,
  255.                         b,
  256.                         a + 1
  257.                     ),
  258.                     logBetaEstimator,
  259.                     10000
  260.                 );

  262.             return new org.drip.function.definition.R1ToR1Property (
  263.                 org.drip.function.definition.R1ToR1Property.EQ,
  264.                 new org.drip.function.definition.R1ToR1 (null)
  265.                 {
  266.                     @Override public double evaluate (
  267.                         final double z)
  268.                         throws java.lang.Exception
  269.                     {
  270.                         return hypergeometricEstimator.derivative (
  271.                             z,
  272.                             1
  273.                         );
  274.                     }
  275.                 },
  276.                 new org.drip.function.definition.R1ToR1 (null)
  277.                 {
  278.                     @Override public double evaluate (
  279.                         final double z)
  280.                         throws java.lang.Exception
  281.                     {
  282.                         return a / z * (
  283.                             java.lang.Math.pow (
  284.                                 1. - z,
  285.                                 -b
  286.                             ) - hypergeometricEstimator.regularHypergeometric (z)
  287.                         );
  288.                     }
  289.                 },
  290.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  291.             );
  292.         }
  293.         catch (java.lang.Exception e)
  294.         {
  295.             e.printStackTrace();
  296.         }

  298.         return null;
  299.     }

  301.     /**
  302.      * Construct the Log (1 + z) Special Case Verifier
  303.      * 
  304.      * @return The Log (1 + z) Special Case Verifier
  305.      */

  307.     public static final org.drip.function.definition.R1ToR1Property LogOnePlusZ()
  308.     {
  309.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  310.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (1000);

  312.         if (null == logBetaEstimator)
  313.         {
  314.             return null;
  315.         }

  317.         try
  318.         {
  319.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator =
  320.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  321.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  322.                         1.,
  323.                         1.,
  324.                         2.
  325.                     ),
  326.                     logBetaEstimator,
  327.                     10000
  328.                 );

  330.             return new org.drip.function.definition.R1ToR1Property (
  331.                 org.drip.function.definition.R1ToR1Property.EQ,
  332.                 new org.drip.function.definition.R1ToR1 (null)
  333.                 {
  334.                     @Override public double evaluate (
  335.                         final double z)
  336.                         throws java.lang.Exception
  337.                     {
  338.                         return z * hypergeometricEstimator.evaluate (-z);
  339.                     }
  340.                 },
  341.                 new org.drip.function.definition.R1ToR1 (null)
  342.                 {
  343.                     @Override public double evaluate (
  344.                         final double z)
  345.                         throws java.lang.Exception
  346.                     {
  347.                         return java.lang.Math.log (1. + z);
  348.                     }
  349.                 },
  350.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  351.             );
  352.         }
  353.         catch (java.lang.Exception e)
  354.         {
  355.             e.printStackTrace();
  356.         }

  358.         return null;
  359.     }

  361.     /**
  362.      * Construct the Inverse Power A Special Case Verifier
  363.      * 
  364.      * @param a A
  365.      * 
  366.      * @return The Inverse Power A Special Case Verifier
  367.      */

  369.     public static final org.drip.function.definition.R1ToR1Property InversePowerA (
  370.         final double a)
  371.     {
  372.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  373.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (1000);

  375.         if (null == logBetaEstimator)
  376.         {
  377.             return null;
  378.         }

  380.         try
  381.         {
  382.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator =
  383.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  384.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  385.                         a,
  386.                         1.,
  387.                         1.
  388.                     ),
  389.                     logBetaEstimator,
  390.                     10000
  391.                 );

  393.             return new org.drip.function.definition.R1ToR1Property (
  394.                 org.drip.function.definition.R1ToR1Property.EQ,
  395.                 new org.drip.function.definition.R1ToR1 (null)
  396.                 {
  397.                     @Override public double evaluate (
  398.                         final double z)
  399.                         throws java.lang.Exception
  400.                     {
  401.                         return hypergeometricEstimator.evaluate (z);
  402.                     }
  403.                 },
  404.                 new org.drip.function.definition.R1ToR1 (null)
  405.                 {
  406.                     @Override public double evaluate (
  407.                         final double z)
  408.                         throws java.lang.Exception
  409.                     {
  410.                         return java.lang.Math.pow (
  411.                             1. - z,
  412.                             -a
  413.                         );
  414.                     }
  415.                 },
  416.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  417.             );
  418.         }
  419.         catch (java.lang.Exception e)
  420.         {
  421.             e.printStackTrace();
  422.         }

  424.         return null;
  425.     }

  427.     /**
  428.      * Construct the Inverse Sine Special Case Verifier
  429.      * 
  430.      * @return The Inverse Sine Special Case Verifier
  431.      */

  433.     public static final org.drip.function.definition.R1ToR1Property InverseSine()
  434.     {
  435.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  436.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (1000);

  438.         if (null == logBetaEstimator)
  439.         {
  440.             return null;
  441.         }

  443.         try
  444.         {
  445.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator =
  446.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  447.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  448.                         0.5,
  449.                         0.5,
  450.                         1.5
  451.                     ),
  452.                     logBetaEstimator,
  453.                     10000
  454.                 );

  456.             return new org.drip.function.definition.R1ToR1Property (
  457.                 org.drip.function.definition.R1ToR1Property.EQ,
  458.                 new org.drip.function.definition.R1ToR1 (null)
  459.                 {
  460.                     @Override public double evaluate (
  461.                         final double z)
  462.                         throws java.lang.Exception
  463.                     {
  464.                         return z * hypergeometricEstimator.evaluate (z * z);
  465.                     }
  466.                 },
  467.                 new org.drip.function.definition.R1ToR1 (null)
  468.                 {
  469.                     @Override public double evaluate (
  470.                         final double z)
  471.                         throws java.lang.Exception
  472.                     {
  473.                         return java.lang.Math.asin (z);
  474.                     }
  475.                 },
  476.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  477.             );
  478.         }
  479.         catch (java.lang.Exception e)
  480.         {
  481.             e.printStackTrace();
  482.         }

  484.         return null;
  485.     }

  487.     /**
  488.      * Construct the Goursat Quadratic Transformation Verifier
  489.      * 
  490.      * @param a A
  491.      * @param b B
  492.      * 
  493.      * @return The Goursat Quadratic Transformation Verifier
  494.      */

  496.     public static final org.drip.function.definition.R1ToR1Property GoursatQuadraticTransformation (
  497.         final double a,
  498.         final double b)
  499.     {
  500.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  501.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  503.         if (null == logBetaEstimator)
  504.         {
  505.             return null;
  506.         }

  508.         try
  509.         {
  510.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator1 =
  511.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  512.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  513.                         a,
  514.                         b,
  515.                         2. * b
  516.                     ),
  517.                     logBetaEstimator,
  518.                     100000
  519.                 );

  521.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator2 =
  522.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  523.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  524.                         0.5 * a,
  525.                         b - 0.5 * a,
  526.                         b + 0.5
  527.                     ),
  528.                     logBetaEstimator,
  529.                     100000
  530.                 );

  532.             return new org.drip.function.definition.R1ToR1Property (
  533.                 org.drip.function.definition.R1ToR1Property.EQ,
  534.                 new org.drip.function.definition.R1ToR1 (null)
  535.                 {
  536.                     @Override public double evaluate (
  537.                         final double z)
  538.                         throws java.lang.Exception
  539.                     {
  540.                         return hypergeometricEstimator1.regularHypergeometric (z);
  541.                     }
  542.                 },
  543.                 new org.drip.function.definition.R1ToR1 (null)
  544.                 {
  545.                     @Override public double evaluate (
  546.                         final double z)
  547.                         throws java.lang.Exception
  548.                     {
  549.                         return java.lang.Math.pow (
  550.                             1. - z,
  551.                             -0.5 * a
  552.                         ) * hypergeometricEstimator2.regularHypergeometric (
  553.                             z * z / (4. * z - 4.)
  554.                         );
  555.                     }
  556.                 },
  557.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  558.             );
  559.         }
  560.         catch (java.lang.Exception e)
  561.         {
  562.             e.printStackTrace();
  563.         }

  565.         return null;
  566.     }

  568.     /**
  569.      * Construct the Goursat Cubic Transformation Verifier
  570.      * 
  571.      * @param a A
  572.      * 
  573.      * @return The Goursat Cubic Transformation Verifier
  574.      */

  576.     public static final org.drip.function.definition.R1ToR1Property GoursatCubicTransformation (
  577.         final double a)
  578.     {
  579.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  580.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  582.         if (null == logBetaEstimator)
  583.         {
  584.             return null;
  585.         }

  587.         try
  588.         {
  589.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator1 =
  590.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  591.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  592.                         1.5 * a,
  593.                         1.5 * a - 0.5,
  594.                         a + 0.5
  595.                     ),
  596.                     logBetaEstimator,
  597.                     100000
  598.                 );

  600.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator2 =
  601.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  602.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  603.                         a - (1. / 3.),
  604.                         a,
  605.                         2. * a
  606.                     ),
  607.                     logBetaEstimator,
  608.                     100000
  609.                 );

  611.             return new org.drip.function.definition.R1ToR1Property (
  612.                 org.drip.function.definition.R1ToR1Property.EQ,
  613.                 new org.drip.function.definition.R1ToR1 (null)
  614.                 {
  615.                     @Override public double evaluate (
  616.                         final double z)
  617.                         throws java.lang.Exception
  618.                     {
  619.                         return hypergeometricEstimator1.regularHypergeometric (-1. * z * z / 3.);
  620.                     }
  621.                 },
  622.                 new org.drip.function.definition.R1ToR1 (null)
  623.                 {
  624.                     @Override public double evaluate (
  625.                         final double z)
  626.                         throws java.lang.Exception
  627.                     {
  628.                         double onePlusZ = 1. + z;

  630.                         return java.lang.Math.pow (
  631.                             onePlusZ,
  632.                             1. - 3. * a
  633.                         ) * hypergeometricEstimator2.regularHypergeometric (
  634.                             2. * z * (3. + z * z) / (onePlusZ * onePlusZ * onePlusZ)
  635.                         );
  636.                     }
  637.                 },
  638.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  639.             );
  640.         }
  641.         catch (java.lang.Exception e)
  642.         {
  643.             e.printStackTrace();
  644.         }

  646.         return null;
  647.     }

  649.     /**
  650.      * Construct the Vidunas Higher Order Transformation Verifier
  651.      * 
  652.      * @return The Vidunas Higher Order Transformation Verifier
  653.      */

  655.     public static final org.drip.function.definition.R1ToR1Property VidunasHigherOrderTransformation()
  656.     {
  657.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  658.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  660.         if (null == logBetaEstimator)
  661.         {
  662.             return null;
  663.         }

  665.         try
  666.         {
  667.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator1 =
  668.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  669.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  670.                         0.25,
  671.                         0.375,
  672.                         0.875
  673.                     ),
  674.                     logBetaEstimator,
  675.                     100000
  676.                 );

  678.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator2 =
  679.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  680.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  681.                         1./ 48.,
  682.                         17. / 48.,
  683.                         0.875
  684.                     ),
  685.                     logBetaEstimator,
  686.                     100000
  687.                 );

  689.             return new org.drip.function.definition.R1ToR1Property (
  690.                 org.drip.function.definition.R1ToR1Property.EQ,
  691.                 new org.drip.function.definition.R1ToR1 (null)
  692.                 {
  693.                     @Override public double evaluate (
  694.                         final double z)
  695.                         throws java.lang.Exception
  696.                     {
  697.                         return java.lang.Math.pow (
  698.                             z * z * z * z - 60. * z * z * z + 134. * z * z - 60. * z + 1.,
  699.                             1. / 16.
  700.                         ) * hypergeometricEstimator1.regularHypergeometric (z);
  701.                     }
  702.                 },
  703.                 new org.drip.function.definition.R1ToR1 (null)
  704.                 {
  705.                     @Override public double evaluate (
  706.                         final double z)
  707.                         throws java.lang.Exception
  708.                     {
  709.                         return hypergeometricEstimator2.regularHypergeometric (
  710.                             -432. * z * (z - 1.) * (z - 1.) * java.lang.Math.pow (
  711.                                 z + 1.,
  712.                                 8.
  713.                             ) * java.lang.Math.pow (
  714.                                 z * z * z * z - 60. * z * z * z + 134. * z * z - 60. * z + 1.,
  715.                                 -3.
  716.                             )
  717.                         );
  718.                     }
  719.                 },
  720.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  721.             );
  722.         }
  723.         catch (java.lang.Exception e)
  724.         {
  725.             e.printStackTrace();
  726.         }

  728.         return null;
  729.     }

  731.     /**
  732.      * Construct the Gauss Van der Monde z = +1 Verifier
  733.      * 
  734.      * @return The Gauss Van der Monde z = +1 Verifier
  735.      */

  737.     public static final org.drip.function.definition.R3ToR1Property GaussVanderMondeZPlusOne()
  738.     {
  739.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  740.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  742.         if (null == logBetaEstimator)
  743.         {
  744.             return null;
  745.         }

  747.         final org.drip.specialfunction.gamma.WindschitlTothAnalytic gammaEstimator =
  748.             new org.drip.specialfunction.gamma.WindschitlTothAnalytic (null);

  750.         try
  751.         {
  752.             return new org.drip.function.definition.R3ToR1Property (
  753.                 org.drip.function.definition.R1ToR1Property.EQ,
  754.                 new org.drip.function.definition.R3ToR1()
  755.                 {
  756.                     @Override public double evaluate (
  757.                         final double a,
  758.                         final double b,
  759.                         final double c)
  760.                         throws java.lang.Exception
  761.                     {
  762.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  763.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  764.                                 a,
  765.                                 b,
  766.                                 c
  767.                             ),
  768.                             logBetaEstimator,
  769.                             100000
  770.                         ).regularHypergeometric (1.);
  771.                     }
  772.                 },
  773.                 new org.drip.function.definition.R3ToR1()
  774.                 {
  775.                     @Override public double evaluate (
  776.                         final double a,
  777.                         final double b,
  778.                         final double c)
  779.                         throws java.lang.Exception
  780.                     {
  781.                         return gammaEstimator.evaluate (c) * gammaEstimator.evaluate (c - a - b) / (
  782.                             gammaEstimator.evaluate (c - a) * gammaEstimator.evaluate (c - b)
  783.                         );
  784.                     }
  785.                 },
  786.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  787.             );
  788.         }
  789.         catch (java.lang.Exception e)
  790.         {
  791.             e.printStackTrace();
  792.         }

  794.         return null;
  795.     }

  797.     /**
  798.      * Construct the Gauss-Dougall z = +1 Verifier
  799.      * 
  800.      * @return The Gauss-Dougall z = +1 Verifier
  801.      */

  803.     public static final org.drip.function.definition.R3ToR1Property GaussDougallZPlusOne()
  804.     {
  805.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  806.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  808.         if (null == logBetaEstimator)
  809.         {
  810.             return null;
  811.         }

  813.         try
  814.         {
  815.             return new org.drip.function.definition.R3ToR1Property (
  816.                 org.drip.function.definition.R1ToR1Property.EQ,
  817.                 new org.drip.function.definition.R3ToR1()
  818.                 {
  819.                     @Override public double evaluate (
  820.                         final double m,
  821.                         final double b,
  822.                         final double c)
  823.                         throws java.lang.Exception
  824.                     {
  825.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  826.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  827.                                 -m,
  828.                                 b,
  829.                                 c
  830.                             ),
  831.                             logBetaEstimator,
  832.                             100000
  833.                         ).regularHypergeometric (1.);
  834.                     }
  835.                 },
  836.                 new org.drip.function.definition.R3ToR1()
  837.                 {
  838.                     @Override public double evaluate (
  839.                         final double m,
  840.                         final double b,
  841.                         final double c)
  842.                         throws java.lang.Exception
  843.                     {
  844.                         return org.drip.numerical.common.NumberUtil.PochhammerSymbol (
  845.                             c - b,
  846.                             (int) m
  847.                         ) / org.drip.numerical.common.NumberUtil.PochhammerSymbol (
  848.                             c,
  849.                             (int) m
  850.                         );
  851.                     }
  852.                 },
  853.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  854.             );
  855.         }
  856.         catch (java.lang.Exception e)
  857.         {
  858.             e.printStackTrace();
  859.         }

  861.         return null;
  862.     }

  864.     /**
  865.      * Construct the Gauss Kummer z = -1 Verifier
  866.      * 
  867.      * @return The Gauss Kummer z = -1 Verifier
  868.      */

  870.     public static final org.drip.function.definition.R2ToR1Property GaussKummerZMinusOne()
  871.     {
  872.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  873.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  875.         if (null == logBetaEstimator)
  876.         {
  877.             return null;
  878.         }

  880.         final org.drip.specialfunction.gamma.WindschitlTothAnalytic gammaEstimator =
  881.             new org.drip.specialfunction.gamma.WindschitlTothAnalytic (null);

  883.         try
  884.         {
  885.             return new org.drip.function.definition.R2ToR1Property (
  886.                 org.drip.function.definition.R1ToR1Property.EQ,
  887.                 new org.drip.function.definition.R2ToR1()
  888.                 {
  889.                     @Override public double evaluate (
  890.                         final double a,
  891.                         final double b)
  892.                         throws java.lang.Exception
  893.                     {
  894.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  895.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  896.                                 a,
  897.                                 b,
  898.                                 1. + a - b
  899.                             ),
  900.                             logBetaEstimator,
  901.                             100000
  902.                         ).regularHypergeometric (-1.);
  903.                     }
  904.                 },
  905.                 new org.drip.function.definition.R2ToR1()
  906.                 {
  907.                     @Override public double evaluate (
  908.                         final double a,
  909.                         final double b)
  910.                         throws java.lang.Exception
  911.                     {
  912.                         return gammaEstimator.evaluate (1. + a - b) * gammaEstimator.evaluate (1. + 0.5 * a)
  913.                         / (
  914.                             gammaEstimator.evaluate (1. + a) * gammaEstimator.evaluate (1. + 0.5 * a - b)
  915.                         );
  916.                     }
  917.                 },
  918.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  919.             );
  920.         }
  921.         catch (java.lang.Exception e)
  922.         {
  923.             e.printStackTrace();
  924.         }

  926.         return null;
  927.     }

  929.     /**
  930.      * Construct the Gauss Second Summation z = 0.5 Verifier
  931.      * 
  932.      * @return The Gauss Second Summation z = 0.5 Verifier
  933.      */

  935.     public static final org.drip.function.definition.R2ToR1Property GaussSecondSummationZPlusHalf()
  936.     {
  937.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  938.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  940.         if (null == logBetaEstimator)
  941.         {
  942.             return null;
  943.         }

  945.         final org.drip.specialfunction.gamma.WindschitlTothAnalytic gammaEstimator =
  946.             new org.drip.specialfunction.gamma.WindschitlTothAnalytic (null);

  948.         try
  949.         {
  950.             return new org.drip.function.definition.R2ToR1Property (
  951.                 org.drip.function.definition.R1ToR1Property.EQ,
  952.                 new org.drip.function.definition.R2ToR1()
  953.                 {
  954.                     @Override public double evaluate (
  955.                         final double a,
  956.                         final double b)
  957.                         throws java.lang.Exception
  958.                     {
  959.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  960.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  961.                                 a,
  962.                                 b,
  963.                                 0.5 * (1. + a + b)
  964.                             ),
  965.                             logBetaEstimator,
  966.                             100000
  967.                         ).regularHypergeometric (0.5);
  968.                     }
  969.                 },
  970.                 new org.drip.function.definition.R2ToR1()
  971.                 {
  972.                     @Override public double evaluate (
  973.                         final double a,
  974.                         final double b)
  975.                         throws java.lang.Exception
  976.                     {
  977.                         return gammaEstimator.evaluate (0.5) * gammaEstimator.evaluate (0.5 * (1. + a + b)) /
  978.                         (
  979.                             gammaEstimator.evaluate (0.5 * (1. + a)) *
  980.                             gammaEstimator.evaluate (0.5 * (1. + b))
  981.                         );
  982.                     }
  983.                 },
  984.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  985.             );
  986.         }
  987.         catch (java.lang.Exception e)
  988.         {
  989.             e.printStackTrace();
  990.         }

  992.         return null;
  993.     }

  995.     /**
  996.      * Construct the Gauss Bailey z = +0.5 Verifier
  997.      * 
  998.      * @return The Gauss Bailey z = +0.5 Verifier
  999.      */

  1001.     public static final org.drip.function.definition.R2ToR1Property GaussBaileyZPlusHalf()
  1002.     {
  1003.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  1004.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  1006.         if (null == logBetaEstimator)
  1007.         {
  1008.             return null;
  1009.         }

  1011.         final org.drip.specialfunction.gamma.WindschitlTothAnalytic gammaEstimator =
  1012.             new org.drip.specialfunction.gamma.WindschitlTothAnalytic (null);

  1014.         try
  1015.         {
  1016.             return new org.drip.function.definition.R2ToR1Property (
  1017.                 org.drip.function.definition.R1ToR1Property.EQ,
  1018.                 new org.drip.function.definition.R2ToR1()
  1019.                 {
  1020.                     @Override public double evaluate (
  1021.                         final double a,
  1022.                         final double c)
  1023.                         throws java.lang.Exception
  1024.                     {
  1025.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  1026.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  1027.                                 a,
  1028.                                 1. - a,
  1029.                                 c
  1030.                             ),
  1031.                             logBetaEstimator,
  1032.                             100000
  1033.                         ).regularHypergeometric (0.5);
  1034.                     }
  1035.                 },
  1036.                 new org.drip.function.definition.R2ToR1()
  1037.                 {
  1038.                     @Override public double evaluate (
  1039.                         final double a,
  1040.                         final double c)
  1041.                         throws java.lang.Exception
  1042.                     {
  1043.                         return gammaEstimator.evaluate (0.5 * c) * gammaEstimator.evaluate (0.5 * (1. + c)) /
  1044.                         (
  1045.                             gammaEstimator.evaluate (0.5 * (c + a)) *
  1046.                             gammaEstimator.evaluate (0.5 * (1. + c - a))
  1047.                         );
  1048.                     }
  1049.                 },
  1050.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  1051.             );
  1052.         }
  1053.         catch (java.lang.Exception e)
  1054.         {
  1055.             e.printStackTrace();
  1056.         }

  1058.         return null;
  1059.     }

  1061.     /**
  1062.      * Construct the First Gessel Stanton Koepf Rational Z Verifier
  1063.      * 
  1064.      * @return The First Gessel Stanton Koepf Rational Z Verifier
  1065.      */

  1067.     public static final org.drip.function.definition.R2ToR1Property FirstGesselStantonKoepf()
  1068.     {
  1069.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  1070.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (100000);

  1072.         if (null == logBetaEstimator)
  1073.         {
  1074.             return null;
  1075.         }

  1077.         try
  1078.         {
  1079.             return new org.drip.function.definition.R2ToR1Property (
  1080.                 org.drip.function.definition.R1ToR1Property.EQ,
  1081.                 new org.drip.function.definition.R2ToR1()
  1082.                 {
  1083.                     @Override public double evaluate (
  1084.                         final double a,
  1085.                         final double z)
  1086.                         throws java.lang.Exception
  1087.                     {
  1088.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  1089.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  1090.                                 a,
  1091.                                 -1. * a,
  1092.                                 0.5
  1093.                             ),
  1094.                             logBetaEstimator,
  1095.                             1000000
  1096.                         ).regularHypergeometric (0.25 * z * z / (z - 1.));
  1097.                     }
  1098.                 },
  1099.                 new org.drip.function.definition.R2ToR1()
  1100.                 {
  1101.                     @Override public double evaluate (
  1102.                         final double a,
  1103.                         final double z)
  1104.                         throws java.lang.Exception
  1105.                     {
  1106.                         return 0.5 * (
  1107.                             java.lang.Math.pow (
  1108.                                 1. - z,
  1109.                                 a
  1110.                             ) + java.lang.Math.pow (
  1111.                                 1. - z,
  1112.                                 -a
  1113.                             )
  1114.                         );
  1115.                     }
  1116.                 },
  1117.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  1118.             );
  1119.         }
  1120.         catch (java.lang.Exception e)
  1121.         {
  1122.             e.printStackTrace();
  1123.         }

  1125.         return null;
  1126.     }

  1128.     /**
  1129.      * Construct the Second Gessel Stanton Koepf Rational Z Verifier
  1130.      * 
  1131.      * @return The Second Gessel Stanton Koepf Rational Z Verifier
  1132.      */

  1134.     public static final org.drip.function.definition.R2ToR1Property SecondGesselStantonKoepf()
  1135.     {
  1136.         final org.drip.function.definition.R2ToR1 logBetaEstimator =
  1137.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (100000);

  1139.         if (null == logBetaEstimator)
  1140.         {
  1141.             return null;
  1142.         }

  1144.         try
  1145.         {
  1146.             return new org.drip.function.definition.R2ToR1Property (
  1147.                 org.drip.function.definition.R1ToR1Property.EQ,
  1148.                 new org.drip.function.definition.R2ToR1()
  1149.                 {
  1150.                     @Override public double evaluate (
  1151.                         final double a,
  1152.                         final double z)
  1153.                         throws java.lang.Exception
  1154.                     {
  1155.                         return new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  1156.                             new org.drip.specialfunction.definition.HypergeometricParameters (
  1157.                                 a,
  1158.                                 -1. * a,
  1159.                                 0.5
  1160.                             ),
  1161.                             logBetaEstimator,
  1162.                             1000000
  1163.                         ).regularHypergeometric (0.5 * (1. - java.lang.Math.cos (z)));
  1164.                     }
  1165.                 },
  1166.                 new org.drip.function.definition.R2ToR1()
  1167.                 {
  1168.                     @Override public double evaluate (
  1169.                         final double a,
  1170.                         final double z)
  1171.                         throws java.lang.Exception
  1172.                     {
  1173.                         return java.lang.Math.cos (a * z);
  1174.                     }
  1175.                 },
  1176.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  1177.             );
  1178.         }
  1179.         catch (java.lang.Exception e)
  1180.         {
  1181.             e.printStackTrace();
  1182.         }

  1184.         return null;
  1185.     }

  1187.     /**
  1188.      * Construct the Gauss Continued Fraction Recursive Verifier
  1189.      * 
  1190.      * @param a A
  1191.      * @param b B
  1192.      * @param c C
  1193.      * 
  1194.      * @return The Gauss Continued Fraction Recursive Verifier
  1195.      */

  1197.     public static final org.drip.function.definition.R1ToR1Property GaussContinuedFractionRecursive (
  1198.         final double a,
  1199.         final double b,
  1200.         final double c)
  1201.     {
  1202.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  1203.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (1000);

  1205.         if (null == logBetaEstimator)
  1206.         {
  1207.             return null;
  1208.         }

  1210.         try
  1211.         {
  1212.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator1 =
  1213.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  1214.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  1215.                         a,
  1216.                         b,
  1217.                         c
  1218.                     ),
  1219.                     logBetaEstimator,
  1220.                     10000
  1221.                 );

  1223.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator2 =
  1224.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  1225.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  1226.                         a + 1,
  1227.                         b,
  1228.                         c + 1
  1229.                     ),
  1230.                     logBetaEstimator,
  1231.                     10000
  1232.                 );

  1234.             return new org.drip.function.definition.R1ToR1Property (
  1235.                 org.drip.function.definition.R1ToR1Property.EQ,
  1236.                 new org.drip.function.definition.R1ToR1 (null)
  1237.                 {
  1238.                     @Override public double evaluate (
  1239.                         final double z)
  1240.                         throws java.lang.Exception
  1241.                     {
  1242.                         return hypergeometricEstimator2.evaluate (z) / hypergeometricEstimator1.evaluate (z);
  1243.                     }
  1244.                 },
  1245.                 new org.drip.function.definition.R1ToR1 (null)
  1246.                 {
  1247.                     @Override public double evaluate (
  1248.                         final double z)
  1249.                         throws java.lang.Exception
  1250.                     {
  1251.                         return 1. / RecursiveGaussContinedFraction (
  1252.                             a,
  1253.                             b,
  1254.                             c,
  1255.                             z,
  1256.                             0,
  1257.                             10
  1258.                         );
  1259.                     }
  1260.                 },
  1261.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  1262.             );
  1263.         }
  1264.         catch (java.lang.Exception e)
  1265.         {
  1266.             e.printStackTrace();
  1267.         }

  1269.         return null;
  1270.     }

  1272.     /**
  1273.      * Construct the Incomplete Beta Verifier
  1274.      * 
  1275.      * @param p P
  1276.      * @param q Q
  1277.      * 
  1278.      * @return The Incomplete Beta Verifier
  1279.      */

  1281.     public static final org.drip.function.definition.R1ToR1Property IncompleteBeta (
  1282.         final double p,
  1283.         final double q)
  1284.     {
  1285.         org.drip.function.definition.R2ToR1 logBetaEstimator =
  1286.             org.drip.specialfunction.beta.LogGammaEstimator.Weierstrass (10000);

  1288.         if (null == logBetaEstimator)
  1289.         {
  1290.             return null;
  1291.         }

  1293.         final org.drip.specialfunction.beta.IncompleteIntegrandEstimator incompleteBetaEstimator =
  1294.             org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (10000);

  1296.         try
  1297.         {
  1298.             final org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator hypergeometricEstimator =
  1299.                 new org.drip.specialfunction.hypergeometric.EulerQuadratureEstimator (
  1300.                     new org.drip.specialfunction.definition.HypergeometricParameters (
  1301.                         p,
  1302.                         1. - q,
  1303.                         p + 1.
  1304.                     ),
  1305.                     logBetaEstimator,
  1306.                     10000
  1307.                 );

  1309.             return new org.drip.function.definition.R1ToR1Property (
  1310.                 org.drip.function.definition.R1ToR1Property.EQ,
  1311.                 new org.drip.function.definition.R1ToR1 (null)
  1312.                 {
  1313.                     @Override public double evaluate (
  1314.                         final double z)
  1315.                         throws java.lang.Exception
  1316.                     {
  1317.                         return java.lang.Math.pow (
  1318.                             z,
  1319.                             p
  1320.                         ) * hypergeometricEstimator.evaluate (z) / p;
  1321.                     }
  1322.                 },
  1323.                 new org.drip.function.definition.R1ToR1 (null)
  1324.                 {
  1325.                     @Override public double evaluate (
  1326.                         final double z)
  1327.                         throws java.lang.Exception
  1328.                     {
  1329.                         return incompleteBetaEstimator.evaluate (
  1330.                             z,
  1331.                             p,
  1332.                             q
  1333.                         );
  1334.                     }
  1335.                 },
  1336.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  1337.             );
  1338.         }
  1339.         catch (java.lang.Exception e)
  1340.         {
  1341.             e.printStackTrace();
  1342.         }

  1344.         return null;
  1345.     }
  1346. }
Created with JaCoCo 0.7.9.201702052155