IncompleteBetaEqualityLemma.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>IncompleteBetaEqualityLemma</i> implements the Equality Lemmas for the Incomplete Beta Estimation. The
  79.  * 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.  *          Davis, P. J. (1959): Leonhard Euler's Integral: A Historical Profile of the Gamma Function
  89.  *              <i>American Mathematical Monthly</i> <b>66 (10)</b> 849-869
  90.  *      </li>
  91.  *      <li>
  92.  *          Whitaker, E. T., and G. N. Watson (1996): <i>A Course on Modern Analysis</i> <b>Cambridge
  93.  *              University Press</b> New York
  94.  *      </li>
  95.  *      <li>
  96.  *          Wikipedia (2019): Beta Function https://en.wikipedia.org/wiki/Beta_function
  97.  *      </li>
  98.  *      <li>
  99.  *          Wikipedia (2019): Gamma Function https://en.wikipedia.org/wiki/Gamma_function
  100.  *      </li>
  101.  *  </ul>
  102.  *
  103.  *  <br><br>
  104.  *  <ul>
  105.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  106.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/FunctionAnalysisLibrary.md">Function Analysis Library</a></li>
  107.  *      <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>
  108.  *      <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>
  109.  *  </ul>
  110.  *
  111.  * @author Lakshmi Krishnamurthy
  112.  */

  114. public class IncompleteBetaEqualityLemma
  115. {

  117.     /**
  118.      * Construct the Identity #1 Verifier
  119.      * 
  120.      * @return The Identity #1 Verifier
  121.      */

  123.     public static final org.drip.function.definition.R2ToR1Property Identity1()
  124.     {
  125.         try
  126.         {
  127.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  128.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  129.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  130.                     org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000)
  131.                         );

  133.             return new org.drip.function.definition.R2ToR1Property (
  134.                 org.drip.function.definition.RxToR1Property.EQ,
  135.                 new org.drip.function.definition.R2ToR1()
  136.                 {
  137.                     @Override public double evaluate (
  138.                         final double a,
  139.                         final double b)
  140.                         throws java.lang.Exception
  141.                     {
  142.                         if (!org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  143.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  144.                         {
  145.                             throw new java.lang.Exception
  146.                                 ("IncompleteBetaEqualityLemma::Identity1::evaluate => Invalid Inputs");
  147.                         }

  149.                         return incompleteRegularizedEstimator.evaluate (
  150.                             0.,
  151.                             a,
  152.                             b
  153.                         );
  154.                     }
  155.                 },
  156.                 new org.drip.function.definition.R2ToR1()
  157.                 {
  158.                     @Override public double evaluate (
  159.                         final double x,
  160.                         final double y)
  161.                         throws java.lang.Exception
  162.                     {
  163.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  164.                             !org.drip.numerical.common.NumberUtil.IsValid (y) || 0. >= y)
  165.                         {
  166.                             throw new java.lang.Exception
  167.                                 ("IncompleteBetaEqualityLemma::Identity1::evaluate => Invalid Inputs");
  168.                         }

  170.                         return 0.;
  171.                     }
  172.                 },
  173.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  174.             );
  175.         }
  176.         catch (java.lang.Exception e)
  177.         {
  178.             e.printStackTrace();
  179.         }

  181.         return null;
  182.     }

  184.     /**
  185.      * Construct the Identity #2 Verifier
  186.      * 
  187.      * @return The Identity #2 Verifier
  188.      */

  190.     public static final org.drip.function.definition.R2ToR1Property Identity2()
  191.     {
  192.         try
  193.         {
  194.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  195.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  196.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  197.                     org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000)
  198.                         );

  200.             return new org.drip.function.definition.R2ToR1Property (
  201.                 org.drip.function.definition.RxToR1Property.EQ,
  202.                 new org.drip.function.definition.R2ToR1()
  203.                 {
  204.                     @Override public double evaluate (
  205.                         final double a,
  206.                         final double b)
  207.                         throws java.lang.Exception
  208.                     {
  209.                         if (!org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  210.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  211.                         {
  212.                             throw new java.lang.Exception
  213.                                 ("IncompleteBetaEqualityLemma::Identity2::evaluate => Invalid Inputs");
  214.                         }

  216.                         return incompleteRegularizedEstimator.evaluate (
  217.                             1.,
  218.                             a,
  219.                             b
  220.                         );
  221.                     }
  222.                 },
  223.                 new org.drip.function.definition.R2ToR1()
  224.                 {
  225.                     @Override public double evaluate (
  226.                         final double x,
  227.                         final double y)
  228.                         throws java.lang.Exception
  229.                     {
  230.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  231.                             !org.drip.numerical.common.NumberUtil.IsValid (y) || 0. >= y)
  232.                         {
  233.                             throw new java.lang.Exception
  234.                                 ("IncompleteBetaEqualityLemma::Identity2::evaluate => Invalid Inputs");
  235.                         }

  237.                         return 1.;
  238.                     }
  239.                 },
  240.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  241.             );
  242.         }
  243.         catch (java.lang.Exception e)
  244.         {
  245.             e.printStackTrace();
  246.         }

  248.         return null;
  249.     }

  251.     /**
  252.      * Construct the Identity #3 Verifier
  253.      * 
  254.      * @return The Identity #3 Verifier
  255.      */

  257.     public static final org.drip.function.definition.R2ToR1Property Identity3()
  258.     {
  259.         try
  260.         {
  261.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  262.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  263.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  264.                     org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000)
  265.                         );

  267.             return new org.drip.function.definition.R2ToR1Property (
  268.                 org.drip.function.definition.RxToR1Property.EQ,
  269.                 new org.drip.function.definition.R2ToR1()
  270.                 {
  271.                     @Override public double evaluate (
  272.                         final double x,
  273.                         final double a)
  274.                         throws java.lang.Exception
  275.                     {
  276.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  277.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a)
  278.                         {
  279.                             throw new java.lang.Exception
  280.                                 ("IncompleteBetaEqualityLemma::Identity3::evaluate => Invalid Inputs");
  281.                         }

  283.                         return incompleteRegularizedEstimator.evaluate (
  284.                             x,
  285.                             a,
  286.                             1.
  287.                         );
  288.                     }
  289.                 },
  290.                 new org.drip.function.definition.R2ToR1()
  291.                 {
  292.                     @Override public double evaluate (
  293.                         final double x,
  294.                         final double a)
  295.                         throws java.lang.Exception
  296.                     {
  297.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  298.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a)
  299.                         {
  300.                             throw new java.lang.Exception
  301.                                 ("IncompleteBetaEqualityLemma::Identity3::evaluate => Invalid Inputs");
  302.                         }

  304.                         return java.lang.Math.pow (
  305.                             x,
  306.                             a
  307.                         );
  308.                     }
  309.                 },
  310.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  311.             );
  312.         }
  313.         catch (java.lang.Exception e)
  314.         {
  315.             e.printStackTrace();
  316.         }

  318.         return null;
  319.     }

  321.     /**
  322.      * Construct the Identity #4 Verifier
  323.      * 
  324.      * @return The Identity #4 Verifier
  325.      */

  327.     public static final org.drip.function.definition.R2ToR1Property Identity4()
  328.     {
  329.         try
  330.         {
  331.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  332.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  333.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  334.                     org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000)
  335.                         );

  337.             return new org.drip.function.definition.R2ToR1Property (
  338.                 org.drip.function.definition.RxToR1Property.EQ,
  339.                 new org.drip.function.definition.R2ToR1()
  340.                 {
  341.                     @Override public double evaluate (
  342.                         final double x,
  343.                         final double b)
  344.                         throws java.lang.Exception
  345.                     {
  346.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  347.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  348.                         {
  349.                             throw new java.lang.Exception
  350.                                 ("IncompleteBetaEqualityLemma::Identity4::evaluate => Invalid Inputs");
  351.                         }

  353.                         return incompleteRegularizedEstimator.evaluate (
  354.                             x,
  355.                             1.,
  356.                             b
  357.                         );
  358.                     }
  359.                 },
  360.                 new org.drip.function.definition.R2ToR1()
  361.                 {
  362.                     @Override public double evaluate (
  363.                         final double x,
  364.                         final double b)
  365.                         throws java.lang.Exception
  366.                     {
  367.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  368.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  369.                         {
  370.                             throw new java.lang.Exception
  371.                                 ("IncompleteBetaEqualityLemma::Identity4::evaluate => Invalid Inputs");
  372.                         }

  374.                         return 1. - java.lang.Math.pow (
  375.                             1. - x,
  376.                             b
  377.                         );
  378.                     }
  379.                 },
  380.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  381.             );
  382.         }
  383.         catch (java.lang.Exception e)
  384.         {
  385.             e.printStackTrace();
  386.         }

  388.         return null;
  389.     }

  391.     /**
  392.      * Construct the Identity #5 Verifier
  393.      * 
  394.      * @return The Identity #5 Verifier
  395.      */

  397.     public static final org.drip.function.definition.R3ToR1Property Identity5()
  398.     {
  399.         try
  400.         {
  401.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  402.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  403.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  404.                     org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000)
  405.                 );

  407.             return new org.drip.function.definition.R3ToR1Property (
  408.                 org.drip.function.definition.RxToR1Property.EQ,
  409.                 new org.drip.function.definition.R3ToR1()
  410.                 {
  411.                     @Override public double evaluate (
  412.                         final double x,
  413.                         final double a,
  414.                         final double b)
  415.                         throws java.lang.Exception
  416.                     {
  417.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  418.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  419.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  420.                         {
  421.                             throw new java.lang.Exception
  422.                                 ("IncompleteBetaEqualityLemma::Identity5::evaluate => Invalid Inputs");
  423.                         }

  425.                         return incompleteRegularizedEstimator.evaluate (
  426.                             x,
  427.                             a,
  428.                             b
  429.                         );
  430.                     }
  431.                 },
  432.                 new org.drip.function.definition.R3ToR1()
  433.                 {
  434.                     @Override public double evaluate (
  435.                         final double x,
  436.                         final double a,
  437.                         final double b)
  438.                         throws java.lang.Exception
  439.                     {
  440.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  441.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  442.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  443.                         {
  444.                             throw new java.lang.Exception
  445.                                 ("IncompleteBetaEqualityLemma::Identity5::evaluate => Invalid Inputs");
  446.                         }

  448.                         return 1. - incompleteRegularizedEstimator.evaluate (
  449.                             1. - x,
  450.                             b,
  451.                             a
  452.                         );
  453.                     }
  454.                 },
  455.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  456.             );
  457.         }
  458.         catch (java.lang.Exception e)
  459.         {
  460.             e.printStackTrace();
  461.         }

  463.         return null;
  464.     }

  466.     /**
  467.      * Construct the Identity #6 Verifier
  468.      * 
  469.      * @return The Identity #6 Verifier
  470.      */

  472.     public static final org.drip.function.definition.R3ToR1Property Identity6()
  473.     {
  474.         final org.drip.specialfunction.beta.IntegrandEstimator integrandEstimator =
  475.             org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000);

  477.         try
  478.         {
  479.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  480.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  481.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  482.                     integrandEstimator
  483.                 );

  485.             return new org.drip.function.definition.R3ToR1Property (
  486.                 org.drip.function.definition.RxToR1Property.EQ,
  487.                 new org.drip.function.definition.R3ToR1()
  488.                 {
  489.                     @Override public double evaluate (
  490.                         final double x,
  491.                         final double a,
  492.                         final double b)
  493.                         throws java.lang.Exception
  494.                     {
  495.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  496.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  497.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  498.                         {
  499.                             throw new java.lang.Exception
  500.                                 ("IncompleteBetaEqualityLemma::Identity6::evaluate => Invalid Inputs");
  501.                         }

  503.                         return incompleteRegularizedEstimator.evaluate (
  504.                             x,
  505.                             a + 1.,
  506.                             b
  507.                         );
  508.                     }
  509.                 },
  510.                 new org.drip.function.definition.R3ToR1()
  511.                 {
  512.                     @Override public double evaluate (
  513.                         final double x,
  514.                         final double a,
  515.                         final double b)
  516.                         throws java.lang.Exception
  517.                     {
  518.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  519.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  520.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  521.                         {
  522.                             throw new java.lang.Exception
  523.                                 ("IncompleteBetaEqualityLemma::Identity6::evaluate => Invalid Inputs");
  524.                         }

  526.                         return incompleteRegularizedEstimator.evaluate (
  527.                             x,
  528.                             a,
  529.                             b
  530.                         ) - java.lang.Math.pow (
  531.                             x,
  532.                             a
  533.                         ) * java.lang.Math.pow (
  534.                             1. - x,
  535.                             b
  536.                         ) / a / integrandEstimator.evaluate (
  537.                             a,
  538.                             b
  539.                         );
  540.                     }
  541.                 },
  542.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  543.             );
  544.         }
  545.         catch (java.lang.Exception e)
  546.         {
  547.             e.printStackTrace();
  548.         }

  550.         return null;
  551.     }

  553.     /**
  554.      * Construct the Identity #7 Verifier
  555.      * 
  556.      * @return The Identity #7 Verifier
  557.      */

  559.     public static final org.drip.function.definition.R3ToR1Property Identity7()
  560.     {
  561.         final org.drip.specialfunction.beta.IntegrandEstimator integrandEstimator =
  562.             org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000);

  564.         try
  565.         {
  566.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  567.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  568.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  569.                     integrandEstimator
  570.                 );

  572.             return new org.drip.function.definition.R3ToR1Property (
  573.                 org.drip.function.definition.RxToR1Property.EQ,
  574.                 new org.drip.function.definition.R3ToR1()
  575.                 {
  576.                     @Override public double evaluate (
  577.                         final double x,
  578.                         final double a,
  579.                         final double b)
  580.                         throws java.lang.Exception
  581.                     {
  582.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  583.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  584.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  585.                         {
  586.                             throw new java.lang.Exception
  587.                                 ("IncompleteBetaEqualityLemma::Identity7::evaluate => Invalid Inputs");
  588.                         }

  590.                         return incompleteRegularizedEstimator.evaluate (
  591.                             x,
  592.                             a,
  593.                             b + 1.
  594.                         );
  595.                     }
  596.                 },
  597.                 new org.drip.function.definition.R3ToR1()
  598.                 {
  599.                     @Override public double evaluate (
  600.                         final double x,
  601.                         final double a,
  602.                         final double b)
  603.                         throws java.lang.Exception
  604.                     {
  605.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  606.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  607.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  608.                         {
  609.                             throw new java.lang.Exception
  610.                                 ("IncompleteBetaEqualityLemma::Identity7::evaluate => Invalid Inputs");
  611.                         }

  613.                         return incompleteRegularizedEstimator.evaluate (
  614.                             x,
  615.                             a,
  616.                             b
  617.                         ) + java.lang.Math.pow (
  618.                             x,
  619.                             a
  620.                         ) * java.lang.Math.pow (
  621.                             1. - x,
  622.                             b
  623.                         ) / b / integrandEstimator.evaluate (
  624.                             a,
  625.                             b
  626.                         );
  627.                     }
  628.                 },
  629.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  630.             );
  631.         }
  632.         catch (java.lang.Exception e)
  633.         {
  634.             e.printStackTrace();
  635.         }

  637.         return null;
  638.     }

  640.     /**
  641.      * Construct the Identity #8 Verifier
  642.      * 
  643.      * @return The Identity #8 Verifier
  644.      */

  646.     public static final org.drip.function.definition.R3ToR1Property Identity8()
  647.     {
  648.         final org.drip.specialfunction.beta.IntegrandEstimator integrandEstimator =
  649.             org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000);

  651.         try
  652.         {
  653.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  654.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  655.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  656.                     integrandEstimator
  657.                 );

  659.             return new org.drip.function.definition.R3ToR1Property (
  660.                 org.drip.function.definition.RxToR1Property.EQ,
  661.                 new org.drip.function.definition.R3ToR1()
  662.                 {
  663.                     @Override public double evaluate (
  664.                         final double x,
  665.                         final double a,
  666.                         final double b)
  667.                         throws java.lang.Exception
  668.                     {
  669.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  670.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  671.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  672.                         {
  673.                             throw new java.lang.Exception
  674.                                 ("IncompleteBetaEqualityLemma::Identity8::evaluate => Invalid Inputs");
  675.                         }

  677.                         return incompleteRegularizedEstimator.evaluate (
  678.                             x,
  679.                             a,
  680.                             b
  681.                         );
  682.                     }
  683.                 },
  684.                 new org.drip.function.definition.R3ToR1()
  685.                 {
  686.                     @Override public double evaluate (
  687.                         final double x,
  688.                         final double a,
  689.                         final double b)
  690.                         throws java.lang.Exception
  691.                     {
  692.                         if (!org.drip.numerical.common.NumberUtil.IsValid (x) || 0. >= x ||
  693.                             !org.drip.numerical.common.NumberUtil.IsValid (a) || 0. >= a ||
  694.                             !org.drip.numerical.common.NumberUtil.IsValid (b) || 0. >= b)
  695.                         {
  696.                             throw new java.lang.Exception
  697.                                 ("IncompleteBetaEqualityLemma::Identity8::evaluate => Invalid Inputs");
  698.                         }

  700.                         return incompleteRegularizedEstimator.evaluate (
  701.                             x / (1. - x),
  702.                             a,
  703.                             1. - a - b
  704.                         );
  705.                     }
  706.                 },
  707.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  708.             );
  709.         }
  710.         catch (java.lang.Exception e)
  711.         {
  712.             e.printStackTrace();
  713.         }

  715.         return null;
  716.     }

  718.     /**
  719.      * Construct the Cumulative Binomial Distribution Verifier
  720.      * 
  721.      * @return The Cumulative Binomial Distribution Verifier
  722.      */

  724.     public static final org.drip.function.definition.R3ToR1Property CumulativeBinomialDistribution()
  725.     {
  726.         try
  727.         {
  728.             final org.drip.specialfunction.beta.IncompleteRegularizedEstimator incompleteRegularizedEstimator
  729.                 = new org.drip.specialfunction.beta.IncompleteRegularizedEstimator (
  730.                     org.drip.specialfunction.beta.IncompleteIntegrandEstimator.EulerFirst (1000),
  731.                     org.drip.specialfunction.beta.IntegrandEstimator.EulerFirstRightPlane (1000)
  732.                 );

  734.             return new org.drip.function.definition.R3ToR1Property (
  735.                 org.drip.function.definition.RxToR1Property.EQ,
  736.                 new org.drip.function.definition.R3ToR1()
  737.                 {
  738.                     @Override public double evaluate (
  739.                         final double p,
  740.                         final double n,
  741.                         final double k)
  742.                         throws java.lang.Exception
  743.                     {
  744.                         if (!org.drip.numerical.common.NumberUtil.IsValid (p) || 0. >= p ||
  745.                             !org.drip.numerical.common.NumberUtil.IsValid (n) || 0. >= n ||
  746.                             !org.drip.numerical.common.NumberUtil.IsValid (k) || 0. >= k)
  747.                         {
  748.                             throw new java.lang.Exception
  749.                                 ("IncompleteBetaEqualityLemma::CumulativeBinomialDistribution::evaluate => Invalid Inputs");
  750.                         }

  752.                         return incompleteRegularizedEstimator.evaluate (
  753.                             1. - p,
  754.                             n - k,
  755.                             k + 1.
  756.                         );
  757.                     }
  758.                 },
  759.                 new org.drip.function.definition.R3ToR1()
  760.                 {
  761.                     @Override public double evaluate (
  762.                         final double p,
  763.                         final double n,
  764.                         final double k)
  765.                         throws java.lang.Exception
  766.                     {
  767.                         if (!org.drip.numerical.common.NumberUtil.IsValid (p) || 0. >= p ||
  768.                             !org.drip.numerical.common.NumberUtil.IsValid (n) || 0. >= n ||
  769.                             !org.drip.numerical.common.NumberUtil.IsValid (k) || 0. >= k)
  770.                         {
  771.                             throw new java.lang.Exception
  772.                                 ("IncompleteBetaEqualityLemma::CumulativeBinomialDistribution::evaluate => Invalid Inputs");
  773.                         }

  775.                         return 1. - incompleteRegularizedEstimator.evaluate (
  776.                             p,
  777.                             k + 1.,
  778.                             n - k
  779.                         );
  780.                     }
  781.                 },
  782.                 org.drip.function.definition.R1ToR1Property.MISMATCH_TOLERANCE
  783.             );
  784.         }
  785.         catch (java.lang.Exception e)
  786.         {
  787.             e.printStackTrace();
  788.         }

  790.         return null;
  791.     }
  792. }
Created with JaCoCo 0.7.9.201702052155