NumberUtil.java

  1. package org.drip.numerical.common;

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

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

  84. /**
  85.  * <i>NumberUtil</i> implements number utility functions. It exposes the following functions:
  86.  * 
  87.  * <br><br>
  88.  *  <ul>
  89.  *      <li>
  90.  *          Verify number/number array validity, and closeness/sign match
  91.  *      </li>
  92.  *      <li>
  93.  *          Factorial Permutation/Combination functionality
  94.  *      </li>
  95.  *      <li>
  96.  *          Dump multi-dimensional array contents
  97.  *      </li>
  98.  *      <li>
  99.  *          Min/Max/Bound the array entries within limits
  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/NumericalAnalysisLibrary.md">Numerical Analysis Library</a></li>
  107.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/numerical">Numerical Quadrature, Differentiation, Eigenization, Linear Algebra, and Utilities</a></li>
  108.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/numerical/common">Primitives/Array Manipulate Format Display Utilities</a></li>
  109.  *  </ul>
  110.  * <br><br>
  111.  * 
  112.  * @author Lakshmi Krishnamurthy
  113.  */

  115. public class NumberUtil {
  116.     private static final double DEFAULT_ABSOLUTE_TOLERANCE = 1.0e-03;
  117.     private static final double DEFAULT_RELATIVE_TOLERANCE = 1.0e-03;

  119.     /**
  120.      * Check if the Input Long is MIN_VALUE or MAX_VALUE
  121.      * 
  122.      * @param l Input Long
  123.      * 
  124.      * @return TRUE - Input Long is MIN_VALUE or MAX_VALUE
  125.      */

  127.     public static final boolean IsValid (
  128.         final long l)
  129.     {
  130.         return java.lang.Long.MIN_VALUE != l && java.lang.Long.MAX_VALUE != l;
  131.     }

  133.     /**
  134.      * Check if the Input Long Array contains a MIN_VALUE or MAX_VALUE
  135.      * 
  136.      * @param al Input Long Array
  137.      * 
  138.      * @return TRUE - Input Long Array contains a MIN_VALUE or MAX_VALUE
  139.      */

  141.     public static final boolean IsValid (
  142.         final long[] al)
  143.     {
  144.         if (null == al) return true;

  146.         for (int i = 0; i < al.length; ++i) {
  147.             if (!IsValid (al[i])) return false;
  148.         }

  150.         return true;
  151.     }

  153.     /**
  154.      * Checks if the input double is Infinite or NaN
  155.      * 
  156.      * @param dbl Input double
  157.      * 
  158.      * @return TRUE - Input double is Infinite or NaN
  159.      */

  161.     public static final boolean IsValid (
  162.         final double dbl)
  163.     {
  164.         return !java.lang.Double.isNaN (dbl) && !java.lang.Double.isInfinite (dbl);
  165.     }

  167.     /**
  168.      * Checks if the input double array contains an Infinite or an NaN
  169.      * 
  170.      * @param adbl Input double array
  171.      * 
  172.      * @return TRUE - Input double contains an Infinite or an NaN
  173.      */

  175.     public static final boolean IsValid (
  176.         final double[] adbl)
  177.     {
  178.         if (null == adbl) return true;

  180.         for (int i = 0; i < adbl.length; ++i) {
  181.             if (!IsValid (adbl[i])) return false;
  182.         }

  184.         return true;
  185.     }

  187.     /**
  188.      * Compare and checks if the two input numbers fall within a specified tolerance
  189.      * 
  190.      * @param dbl1 Number #1
  191.      * @param dbl2 Number #2
  192.      * @param dblAbsoluteTolerance Absolute Tolerance
  193.      * @param dblRelativeTolerance Relative Tolerance
  194.      * 
  195.      * @return TRUE if they fall within the tolerance
  196.      */

  198.     public static final boolean WithinTolerance (
  199.         final double dbl1,
  200.         final double dbl2,
  201.         final double dblAbsoluteTolerance,
  202.         final double dblRelativeTolerance)
  203.     {
  204.         if (!IsValid (dbl1) || !IsValid (dbl2)) return false;

  206.         if (dblAbsoluteTolerance >= java.lang.Math.abs (dbl1)) {
  207.             if (dblAbsoluteTolerance >= java.lang.Math.abs (dbl2)) return true;

  209.             return false;
  210.         }

  212.         if (dblRelativeTolerance >= java.lang.Math.abs ((dbl2 - dbl1) / dbl1)) return true;

  214.         return false;
  215.     }

  217.     /**
  218.      * Compare and checks if the two input numbers fall within a specified tolerance
  219.      * 
  220.      * @param dbl1 Number #1
  221.      * @param dbl2 Number #2
  222.      * 
  223.      * @return TRUE if they fall within the tolerance
  224.      */

  226.     public static final boolean WithinTolerance (
  227.         final double dbl1,
  228.         final double dbl2)
  229.     {
  230.         return WithinTolerance (dbl1, dbl2, DEFAULT_ABSOLUTE_TOLERANCE, DEFAULT_RELATIVE_TOLERANCE);
  231.     }

  233.     /**
  234.      * This function implements Factorial N.
  235.      * 
  236.      * @param n N
  237.      * 
  238.      * @return Factorial N
  239.      */

  241.     public static final int Factorial (
  242.         final int n)
  243.     {
  244.         int iNFact = 1;

  246.         for (int i = 1; i <= n; ++i)
  247.             iNFact *= i;

  249.         return iNFact;
  250.     }

  252.     /**
  253.      * This function implements N Permute K.
  254.      * 
  255.      * @param n N
  256.      * @param k K
  257.      * 
  258.      * @return N Permute K
  259.      */

  261.     public static final int NPK (
  262.         final int n,
  263.         final int k)
  264.     {
  265.         int iK = n < k ? n : k;
  266.         int iN = n > k ? n : k;

  268.         return Factorial (iN) / Factorial (iK);
  269.     }

  271.     /**
  272.      * This function implements N choose K.
  273.      * 
  274.      * @param n N
  275.      * @param k K
  276.      * 
  277.      * @return N choose K
  278.      */

  280.     public static final int NCK (
  281.         final int n,
  282.         final int k)
  283.     {
  284.         int iK = n < k ? n : k;
  285.         int iN = n > k ? n : k;

  287.         return Factorial (iN) / Factorial (iK) / Factorial (iN - iK);
  288.     }

  290.     /**
  291.      * Bound the input to within (floor, Ceiling), i.e., compute Min (Max (floor, X), Ceiling)
  292.      * 
  293.      * @param dblX Input Number
  294.      * @param dblFloor Floor
  295.      * @param dblCeiling Ceiling
  296.      * 
  297.      * @return Min (Max (floor, X), Ceiling)
  298.      * 
  299.      * @throws java.lang.Exception Thrown if the inputs are invalid
  300.      */

  302.     public static final double Bound (
  303.         final double dblX,
  304.         final double dblFloor,
  305.         final double dblCeiling)
  306.         throws java.lang.Exception
  307.     {
  308.         if (!IsValid (dblX) || !IsValid (dblFloor)|| !IsValid (dblCeiling) || dblFloor > dblCeiling)
  309.             throw new java.lang.Exception ("NumberUtil::Bound => Invalid Inputs");

  311.         double dblBound = dblX < dblFloor ? dblFloor : dblX;
  312.         return dblBound > dblCeiling ? dblCeiling : dblBound;
  313.     }

  315.     /**
  316.      * Retrieve the Minimum Element in the specified Array
  317.      * 
  318.      * @param adbl Array of elements
  319.      * 
  320.      * @return The Minimum Element
  321.      * 
  322.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  323.      */

  325.     public static final double Minimum (
  326.         final double[] adbl)
  327.         throws java.lang.Exception
  328.     {
  329.         if (!IsValid (adbl)) throw new java.lang.Exception ("NumberUtil::Minimum => Invalid Inputs");

  331.         double dblMinimum = adbl[0];
  332.         int iNumElement = adbl.length;

  334.         for (int i = 1; i < iNumElement; ++i)
  335.             dblMinimum = dblMinimum < adbl[i] ? dblMinimum : adbl[i];

  337.         return dblMinimum;
  338.     }

  340.     /**
  341.      * Retrieve the Maximum Element in the specified Array
  342.      * 
  343.      * @param adbl Array of elements
  344.      * 
  345.      * @return The Maximum Element
  346.      * 
  347.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  348.      */

  350.     public static final double Maximum (
  351.         final double[] adbl)
  352.         throws java.lang.Exception
  353.     {
  354.         if (!IsValid (adbl)) throw new java.lang.Exception ("NumberUtil::Maximum => Invalid Inputs");

  356.         double dblMaximum = adbl[0];
  357.         int iNumElement = adbl.length;

  359.         for (int i = 1; i < iNumElement; ++i)
  360.             dblMaximum = dblMaximum > adbl[i] ? dblMaximum : adbl[i];

  362.         return dblMaximum;
  363.     }

  365.     /**
  366.      * Check if the specified array contains elements all of the same sign
  367.      * 
  368.      * @param adbl Array of elements
  369.      * 
  370.      * @return TRUE - Same Sign
  371.      * 
  372.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  373.      */

  375.     public static final boolean SameSign (
  376.         final double[] adbl)
  377.         throws java.lang.Exception
  378.     {
  379.         if (!IsValid (adbl)) throw new java.lang.Exception ("NumberUtil::SameSign => Invalid Inputs");

  381.         if (adbl[0] <= 0.) return false;

  383.         int iNumElement = adbl.length;

  385.         for (int i = 1; i < iNumElement; ++i) {
  386.             if (adbl[0] * adbl[i] <= 0.) return false;
  387.         }

  389.         return true;
  390.     }

  392.     /**
  393.      * Print the contents of the 1D array
  394.      * 
  395.      * @param strName Label Name
  396.      * @param adblA The 1D array
  397.      * @param bBailOnNaN Bail on encountering an NaN
  398.      * 
  399.      * @return TRUE - Print Successful
  400.      */

  402.     public static final boolean Print1DArray (
  403.         final java.lang.String strName,
  404.         final double[] adblA,
  405.         final boolean bBailOnNaN)
  406.     {
  407.         if (null == adblA || 0 == adblA.length) return false;

  409.         int iSize = adblA.length;

  411.         for (int i = 0; i < iSize; ++i) {
  412.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblA[i]) && bBailOnNaN) return false;

  414.             System.out.println (strName + "[" + i + "] = " + adblA[i]);
  415.         }

  417.         return true;
  418.     }

  420.     /**
  421.      * Print the contents of the 1D array to the Specified Decimal Location
  422.      * 
  423.      * @param strName Label Name
  424.      * @param adblA The 1D array
  425.      * @param iNumDecimal Number of Decimal Places to Display
  426.      * @param bBailOnNaN Bail on encountering an NaN
  427.      * 
  428.      * @return TRUE - Print Successful
  429.      */

  431.     public static final boolean Print1DArray (
  432.         final java.lang.String strName,
  433.         final double[] adblA,
  434.         final int iNumDecimal,
  435.         final boolean bBailOnNaN)
  436.     {
  437.         if (null == adblA || 0 == adblA.length) return false;

  439.         int iSize = adblA.length;

  441.         for (int i = 0; i < iSize; ++i) {
  442.             if (!org.drip.numerical.common.NumberUtil.IsValid (adblA[i]) && bBailOnNaN) return false;

  444.             System.out.println (strName + "[" + i + "] = " + org.drip.numerical.common.FormatUtil.FormatDouble
  445.                 (adblA[i], 1, iNumDecimal, 1.));
  446.         }

  448.         return true;
  449.     }

  451.     /**
  452.      * Print the contents of the 2D array
  453.      * 
  454.      * @param strName Label Name
  455.      * @param aadblA The 2D array
  456.      * @param bBailOnNaN Bail on encountering an NaN
  457.      * 
  458.      * @return TRUE - Print Successful
  459.      */

  461.     public static final boolean Print2DArray (
  462.         final java.lang.String strName,
  463.         final double[][] aadblA,
  464.         final boolean bBailOnNaN)
  465.     {
  466.         if (null == aadblA) return false;

  468.         int iRowSize = aadblA.length;

  470.         if (0 == iRowSize || null == aadblA[0]) return false;

  472.         int iColSize = aadblA[0].length;

  474.         if (0 == iColSize) return false;

  476.         for (int i = 0; i < iRowSize; ++i) {
  477.             for (int j = 0; j < iColSize; ++j) {
  478.                 if (!org.drip.numerical.common.NumberUtil.IsValid (aadblA[i][j]) && bBailOnNaN) return false;

  480.                 System.out.println (strName + "[" + i + "][" + j + "] = " +
  481.                     org.drip.numerical.common.FormatUtil.FormatDouble (aadblA[i][j], 1, 6, 1.));
  482.             }
  483.         }

  485.         return true;
  486.     }

  488.     /**
  489.      * Print the Contents of the 2D Array Pair
  490.      * 
  491.      * @param strLeftLabel Left Label
  492.      * @param strRightLabel Right Label
  493.      * @param aadblLeft The Left 2D array
  494.      * @param aadblRight The Right 2D array
  495.      * @param bBailOnNaN Bail on encountering an NaN
  496.      * 
  497.      * @return TRUE - Print Successful
  498.      */

  500.     public static final boolean Print2DArrayPair (
  501.         final java.lang.String strLeftLabel,
  502.         final java.lang.String strRightLabel,
  503.         final double[][] aadblLeft,
  504.         final double[][] aadblRight,
  505.         final boolean bBailOnNaN)
  506.     {
  507.         if (null == aadblLeft || null == aadblRight) return false;

  509.         int iSize = aadblLeft.length;

  511.         if (0 == iSize || iSize != aadblRight.length) return false;

  513.         for (int i = 0; i < iSize; ++i) {
  514.             for (int j = 0; j < iSize; ++j) {
  515.                 if (!org.drip.numerical.common.NumberUtil.IsValid (aadblLeft[i][j]) &&
  516.                     !org.drip.numerical.common.NumberUtil.IsValid (aadblRight[i][j]) && bBailOnNaN)
  517.                     return false;

  519.                 System.out.println (strLeftLabel + "[" + i + "][" + j + "] = " +
  520.                     org.drip.numerical.common.FormatUtil.FormatDouble (aadblLeft[i][j], 1, 6, 1.) + "  |  " +
  521.                         strRightLabel + "[" + i + "][" + j + "] = " +
  522.                             org.drip.numerical.common.FormatUtil.FormatDouble (aadblRight[i][j], 1, 6, 1.));
  523.             }
  524.         }

  526.         return true;
  527.     }

  529.     /**
  530.      * Print the Contents of the 2D Array Triplet
  531.      * 
  532.      * @param strLeftLabel Left Label
  533.      * @param strMiddleLabel Middle Label
  534.      * @param strRightLabel Right Label
  535.      * @param aadblLeft The Left 2D array
  536.      * @param aadblMiddle The Middle 2D array
  537.      * @param aadblRight The Right 2D array
  538.      * @param bBailOnNaN Bail on encountering an NaN
  539.      * 
  540.      * @return TRUE - Print Successful
  541.      */

  543.     public static final boolean Print2DArrayTriplet (
  544.         final java.lang.String strLeftLabel,
  545.         final java.lang.String strMiddleLabel,
  546.         final java.lang.String strRightLabel,
  547.         final double[][] aadblLeft,
  548.         final double[][] aadblMiddle,
  549.         final double[][] aadblRight,
  550.         final boolean bBailOnNaN)
  551.     {
  552.         if (null == aadblLeft || null == aadblMiddle || null == aadblRight) return false;

  554.         int iSize = aadblLeft.length;

  556.         if (0 == iSize || iSize != aadblMiddle.length || iSize != aadblRight.length) return false;

  558.         for (int i = 0; i < iSize; ++i) {
  559.             for (int j = 0; j < iSize; ++j) {
  560.                 if (!org.drip.numerical.common.NumberUtil.IsValid (aadblLeft[i][j]) &&
  561.                         !org.drip.numerical.common.NumberUtil.IsValid (aadblLeft[i][j]) &&
  562.                             !org.drip.numerical.common.NumberUtil.IsValid (aadblRight[i][j]) && bBailOnNaN)
  563.                     return false;

  565.                 System.out.println (strLeftLabel + "[" + i + "][" + j + "] = " +
  566.                     org.drip.numerical.common.FormatUtil.FormatDouble (aadblLeft[i][j], 1, 6, 1.) + "  |  " +
  567.                         strMiddleLabel + "[" + i + "][" + j + "] = " +
  568.                             org.drip.numerical.common.FormatUtil.FormatDouble (aadblMiddle[i][j], 1, 6, 1.) +
  569.                                 "  |  " + strRightLabel + "[" + i + "][" + j + "] = " +
  570.                                     org.drip.numerical.common.FormatUtil.FormatDouble (aadblRight[i][j], 1, 6,
  571.                                         1.));
  572.             }
  573.         }

  575.         return true;
  576.     }

  578.     /**
  579.      * Print the Matrix Contents
  580.      * 
  581.      * @param strName Name of the Matrix
  582.      * @param aadblA Matrix
  583.      * 
  584.      * @return TRUE - Matrix Contents Successfully printed
  585.      */

  587.     public static final boolean PrintMatrix (
  588.         final java.lang.String strName,
  589.         final double[][] aadblA)
  590.     {
  591.         if (null == aadblA || 0 == aadblA.length) return false;

  593.         int iSize = aadblA.length;

  595.         for (int i = 0; i < iSize; ++i) {
  596.             java.lang.String strDump = strName  + " => ";

  598.             for (int j = 0; j < iSize; ++j)
  599.                 strDump += org.drip.numerical.common.FormatUtil.FormatDouble (aadblA[i][j], 1, 6, 1.) + " |";

  601.             System.out.println (strDump);
  602.         }

  604.         return true;
  605.     }

  607.     /**
  608.      * Compute (n - 0.5)!
  609.      * 
  610.      * @param n n
  611.      * 
  612.      * @return (n - 0.5)! Value
  613.      * 
  614.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  615.      */

  617.     public static final double HalfDownShiftedFactorial (
  618.         final int n)
  619.         throws java.lang.Exception
  620.     {
  621.         if (-1 >= n)
  622.         {
  623.             throw new java.lang.Exception ("NumberUtil::HalfDownShiftedFactorial => Invalid Inputs");
  624.         }

  626.         double halfDownShiftedFactorial = java.lang.Math.sqrt (java.lang.Math.PI);

  628.         for (double index = 1; index < n; ++index)
  629.         {
  630.             halfDownShiftedFactorial = halfDownShiftedFactorial * (index + 0.5);
  631.         }

  633.         return halfDownShiftedFactorial;
  634.     }

  636.     /**
  637.      * Compute (2n - 1)!!
  638.      * 
  639.      * @param n n
  640.      * 
  641.      * @return (2n - 1)!!
  642.      * 
  643.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  644.      */

  646.     public static final double DoubleFactorial (
  647.         final int n)
  648.         throws java.lang.Exception
  649.     {
  650.         if (-1 >= n)
  651.         {
  652.             throw new java.lang.Exception ("NumberUtil::DoubleFactorial => Invalid Inputs");
  653.         }

  655.         double doubleFactorial = 1.;

  657.         for (int index = 1; index <= n; ++index)
  658.         {
  659.             doubleFactorial = doubleFactorial * (2. * n - 1.);
  660.         }

  662.         return doubleFactorial;
  663.     }

  665.     /**
  666.      * Compute the Rising Pochhammer Symbol for the Specified s and k
  667.      * 
  668.      * @param s s
  669.      * @param k k
  670.      * 
  671.      * @return The Rising Pochhammer Symbol
  672.      * 
  673.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  674.      */

  676.     public static final double RisingPochhammerSymbol (
  677.         final double s,
  678.         final int k)
  679.         throws java.lang.Exception
  680.     {
  681.         if (!org.drip.numerical.common.NumberUtil.IsValid (s) || 0 > k)
  682.         {
  683.             throw new java.lang.Exception ("NumberUtil::RisingPochhammerSymbol => Invalid Inputs");
  684.         }

  686.         if (0 == k)
  687.         {
  688.             return 1.;
  689.         }

  691.         double pochhammerSymbol = s;

  693.         for (int index = 1; index < k; ++index)
  694.         {
  695.             pochhammerSymbol = pochhammerSymbol * (s + index);
  696.         }

  698.         return pochhammerSymbol;
  699.     }

  701.     /**
  702.      * Compute the Pochhammer Symbol for the Specified s and k
  703.      * 
  704.      * @param s s
  705.      * @param k k
  706.      * 
  707.      * @return Pochhammer Symbol
  708.      * 
  709.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  710.      */

  712.     public static final double PochhammerSymbol (
  713.         final double s,
  714.         final int k)
  715.         throws java.lang.Exception
  716.     {
  717.         if (!org.drip.numerical.common.NumberUtil.IsValid (s) || 0 > k)
  718.         {
  719.             throw new java.lang.Exception ("NumberUtil::PochhammerSymbol => Invalid Inputs");
  720.         }

  722.         double pochhammerSymbol = s;

  724.         for (int index = 1; index < k; ++index)
  725.         {
  726.             pochhammerSymbol = pochhammerSymbol * (s + index);
  727.         }

  729.         return pochhammerSymbol;
  730.     }

  732.     /**
  733.      * Indicate if z is an Integer
  734.      * 
  735.      * @param z Z
  736.      * 
  737.      * @return TRUE - z is an Integer
  738.      * 
  739.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  740.      */

  742.     public static final boolean IsInteger (
  743.         final double z)
  744.         throws java.lang.Exception
  745.     {
  746.         if (!org.drip.numerical.common.NumberUtil.IsValid (z))
  747.         {
  748.             throw new java.lang.Exception ("NumberUtil::IsInteger => Invalid Inputs");
  749.         }

  751.         double absoluteZ = java.lang.Math.abs (z);

  753.         return 0. == absoluteZ - (int) absoluteZ;
  754.     }

  756.     /**
  757.      * Indicate if z is a Positive Integer
  758.      * 
  759.      * @param z Z
  760.      * 
  761.      * @return TRUE - z is a Positive Integer
  762.      * 
  763.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  764.      */

  766.     public static final boolean IsPositiveInteger (
  767.         final double z)
  768.         throws java.lang.Exception
  769.     {
  770.         return IsInteger (z) && z > 0.;
  771.     }

  773.     /**
  774.      * Indicate if z is a Non-Positive Integer
  775.      * 
  776.      * @param z Z
  777.      * 
  778.      * @return TRUE - z is a Non-Positive Integer
  779.      * 
  780.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  781.      */

  783.     public static final boolean IsNonPositiveInteger (
  784.         final double z)
  785.         throws java.lang.Exception
  786.     {
  787.         return IsInteger (z) && z <= 0.;
  788.     }

  790.     /**
  791.      * Indicate if z is a Negative Integer
  792.      * 
  793.      * @param z Z
  794.      * 
  795.      * @return TRUE - z is a Negative Integer
  796.      * 
  797.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  798.      */

  800.     public static final boolean IsNegativeInteger (
  801.         final double z)
  802.         throws java.lang.Exception
  803.     {
  804.         return IsInteger (z) && z < 0.;
  805.     }

  807.     /**
  808.      * Indicate if z is a Non-Negative Integer
  809.      * 
  810.      * @param z Z
  811.      * 
  812.      * @return TRUE - z is a Non-Negative Integer
  813.      * 
  814.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  815.      */

  817.     public static final boolean IsNonNegativeInteger (
  818.         final double z)
  819.         throws java.lang.Exception
  820.     {
  821.         return IsInteger (z) && z >= 0.;
  822.     }

  824.     /**
  825.      * Indicate the Sign of z
  826.      * 
  827.      * @param z Z
  828.      * 
  829.      * @return Sign of z
  830.      * 
  831.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  832.      */

  834.     public static final double Sign (
  835.         final double z)
  836.         throws java.lang.Exception
  837.     {
  838.         if (!IsValid (z))
  839.         {
  840.             throw new java.lang.Exception ("NumberUtil::Sign => Invalid Inputs");
  841.         }

  843.         return 0. == z ? 1. : java.lang.Math.abs (z) / z;
  844.     }

  846.     /**
  847.      * Check if the Array Elements are Normalized and Positive
  848.      * 
  849.      * @param array Array
  850.      * 
  851.      * @return TRUE - The Array Elements are Normalized and Positive
  852.      */

  854.     public static final boolean NormalizedPositive (
  855.         final double[] array)
  856.     {
  857.         if (null == array)
  858.         {
  859.             return false;
  860.         }

  862.         double sum = 0.;
  863.         int size = array.length;

  865.         if (0 == size)
  866.         {
  867.             return false;
  868.         }

  870.         for (int index = 0; index < size; ++index)
  871.         {
  872.             if (!org.drip.numerical.common.NumberUtil.IsValid (array[index]) || 0. >= array[index])
  873.             {
  874.                 return false;
  875.             }

  877.             sum = sum + array[index];
  878.         }

  880.         return 1. == sum;
  881.     }

  883.     /**
  884.      * Retrieve the Fractional Part of z
  885.      * 
  886.      * @param z Z
  887.      * 
  888.      * @return The Fractional Part of z
  889.      * 
  890.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  891.      */

  893.     public static final double Fractional (
  894.         final double z)
  895.         throws java.lang.Exception
  896.     {
  897.         if (!IsValid (
  898.             z
  899.         ))
  900.         {
  901.             throw new java.lang.Exception (
  902.                 "NumberUtil::Fractional => Invalid Inputs"
  903.             );
  904.         }

  906.         return z - (int) z;
  907.     }

  909.     /**
  910.      * Retrieve the Reciprocal Integer Floor of z
  911.      * 
  912.      * @param z Z
  913.      * 
  914.      * @return The Reciprocal Integer Floor of z
  915.      * 
  916.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  917.      */

  919.     public static final int ReciprocalIntegerFloor (
  920.         final double z)
  921.         throws java.lang.Exception
  922.     {
  923.         if (!IsValid (
  924.             z
  925.         ))
  926.         {
  927.             throw new java.lang.Exception (
  928.                 "NumberUtil::ReciprocalIntegerFloor => Invalid Inputs"
  929.             );
  930.         }

  932.         return (int) (1. / z);
  933.     }
  934. }
Created with JaCoCo 0.7.9.201702052155