commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Luc Maisonobe <Luc.Maison...@free.fr>
Subject Re: svn commit: r1083323 - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/special/ test/java/org/apache/commons/math/special/
Date Sun, 20 Mar 2011 11:50:24 GMT
Le 20/03/2011 11:12, Gilles Sadowski a écrit :
> Hi.
> 
>> Gilles,
>>
>> This should have been done in three separate commits.
>>
>> The first one, at least, should have been separated.  It is easier
>> for reviewers and makes the commit log clearer if we separate
>> formatting / javadoc cleanup commits from those that update or
>> change the code.  The JIRA reference will pull all of these diffs
>> under the referenced issue.  It is better if the commits that
>> reference the issue are directly related to the issue.
> 
> Yes, it would be better. But I find it not so bad, as a compromise between
> reviewers's (potential) work and my (actual) work. When the change brought
> by the issue (changing the exceptions) implies modifications in the unit
> tests, and I see that they are written in pre-Junit4 format, I do both types
> of changes. It is pretty obvious which is which. Ditto for Javadoc: the
> exception is referenced in the Javadoc, and when I spot something else to be
> changed too, I do it.
> 
> For such trivial changes, I simply don't want to do it in several passes.
> 
> I do the work (MATH-423) incrementally. Now, if other people would
> participate to that task and all unit tests would be upgraded, that would
> solve your problem. [This issue is a trivial task that was opened more than
> five months ago.]

I'll take care of it.
I already did similar stuff for another library using sed scripts. This
is also how I handled converting the calls from Math to FastMath
recently and it works quite well.

Luc

> 
> 
> Regards,
> Gilles
> 
>>
>> Thanks,
>>
>> Phil
>>> Modified:
>>>     commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Beta.java
>>>     commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Erf.java
>>>     commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Gamma.java
>>>     commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/BetaTest.java
>>>     commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/ErfTest.java
>>>     commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/GammaTest.java
>>>
>>> Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Beta.java
>>> URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Beta.java?rev=1083323&r1=1083322&r2=1083323&view=diff
>>> ==============================================================================
>>> --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Beta.java (original)
>>> +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Beta.java Sat Mar 19 22:49:59 2011
>>> @@ -16,7 +16,6 @@
>>>   */
>>>  package org.apache.commons.math.special;
>>>  
>>> -import org.apache.commons.math.MathException;
>>>  import org.apache.commons.math.util.ContinuedFraction;
>>>  import org.apache.commons.math.util.FastMath;
>>>  
>>> @@ -27,31 +26,28 @@ import org.apache.commons.math.util.Fast
>>>   * @version $Revision$ $Date$
>>>   */
>>>  public class Beta {
>>> -
>>>      /** Maximum allowed numerical error. */
>>>      private static final double DEFAULT_EPSILON = 10e-15;
>>>  
>>>      /**
>>>       * Default constructor.  Prohibit instantiation.
>>>       */
>>> -    private Beta() {
>>> -        super();
>>> -    }
>>> +    private Beta() {}
>>>  
>>>      /**
>>>       * Returns the
>>>       * <a href="http://mathworld.wolfram.com/RegularizedBetaFunction.html">
>>>       * regularized beta function</a> I(x, a, b).
>>>       *
>>> -     * @param x the value.
>>> -     * @param a the a parameter.
>>> -     * @param b the b parameter.
>>> -     * @return the regularized beta function I(x, a, b)
>>> +     * @param x Value.
>>> +     * @param a Parameter {@code a}.
>>> +     * @param b Parameter {@code b}.
>>> +     * @return the regularized beta function I(x, a, b).
>>> +     * @throws org.apache.commons.math.exception.MaxCountExceededException
>>> +     * if the algorithm fails to converge.
>>>       * @throws MathException if the algorithm fails to converge.
>>>       */
>>> -    public static double regularizedBeta(double x, double a, double b)
>>> -        throws MathException
>>> -    {
>>> +    public static double regularizedBeta(double x, double a, double b) {
>>>          return regularizedBeta(x, a, b, DEFAULT_EPSILON, Integer.MAX_VALUE);
>>>      }
>>>  
>>> @@ -60,18 +56,19 @@ public class Beta {
>>>       * <a href="http://mathworld.wolfram.com/RegularizedBetaFunction.html">
>>>       * regularized beta function</a> I(x, a, b).
>>>       *
>>> -     * @param x the value.
>>> -     * @param a the a parameter.
>>> -     * @param b the b parameter.
>>> +     * @param x Value.
>>> +     * @param a Parameter {@code a}.
>>> +     * @param b Parameter {@code b}.
>>>       * @param epsilon When the absolute value of the nth item in the
>>> -     *                series is less than epsilon the approximation ceases
>>> -     *                to calculate further elements in the series.
>>> +     * series is less than epsilon the approximation ceases to calculate
>>> +     * further elements in the series.
>>>       * @return the regularized beta function I(x, a, b)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @throws org.apache.commons.math.exception.MaxCountExceededException
>>> +     * if the algorithm fails to converge.
>>>       */
>>> -    public static double regularizedBeta(double x, double a, double b,
>>> -        double epsilon) throws MathException
>>> -    {
>>> +    public static double regularizedBeta(double x,
>>> +                                         double a, double b,
>>> +                                         double epsilon) {
>>>          return regularizedBeta(x, a, b, epsilon, Integer.MAX_VALUE);
>>>      }
>>>  
>>> @@ -79,15 +76,16 @@ public class Beta {
>>>       * Returns the regularized beta function I(x, a, b).
>>>       *
>>>       * @param x the value.
>>> -     * @param a the a parameter.
>>> -     * @param b the b parameter.
>>> +     * @param a Parameter {@code a}.
>>> +     * @param b Parameter {@code b}.
>>>       * @param maxIterations Maximum number of "iterations" to complete.
>>>       * @return the regularized beta function I(x, a, b)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @throws org.apache.commons.math.exception.MaxCountExceededException
>>> +     * if the algorithm fails to converge.
>>>       */
>>> -    public static double regularizedBeta(double x, double a, double b,
>>> -        int maxIterations) throws MathException
>>> -    {
>>> +    public static double regularizedBeta(double x,
>>> +                                         double a, double b,
>>> +                                         int maxIterations) {
>>>          return regularizedBeta(x, a, b, DEFAULT_EPSILON, maxIterations);
>>>      }
>>>  
>>> @@ -105,23 +103,28 @@ public class Beta {
>>>       * </ul>
>>>       *
>>>       * @param x the value.
>>> -     * @param a the a parameter.
>>> -     * @param b the b parameter.
>>> +     * @param a Parameter {@code a}.
>>> +     * @param b Parameter {@code b}.
>>>       * @param epsilon When the absolute value of the nth item in the
>>> -     *                series is less than epsilon the approximation ceases
>>> -     *                to calculate further elements in the series.
>>> +     * series is less than epsilon the approximation ceases to calculate
>>> +     * further elements in the series.
>>>       * @param maxIterations Maximum number of "iterations" to complete.
>>>       * @return the regularized beta function I(x, a, b)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @throws org.apache.commons.math.exception.MaxCountExceededException
>>> +     * if the algorithm fails to converge.
>>>       */
>>> -    public static double regularizedBeta(double x, final double a,
>>> -        final double b, double epsilon, int maxIterations) throws MathException
>>> -    {
>>> +    public static double regularizedBeta(double x,
>>> +                                         final double a, final double b,
>>> +                                         double epsilon, int maxIterations) {
>>>          double ret;
>>>  
>>> -        if (Double.isNaN(x) || Double.isNaN(a) || Double.isNaN(b) || (x < 0) ||
>>> -            (x > 1) || (a <= 0.0) || (b <= 0.0))
>>> -        {
>>> +        if (Double.isNaN(x) ||
>>> +            Double.isNaN(a) ||
>>> +            Double.isNaN(b) ||
>>> +            x < 0 ||
>>> +            x > 1 ||
>>> +            a <= 0.0 ||
>>> +            b <= 0.0) {
>>>              ret = Double.NaN;
>>>          } else if (x > (a + 1.0) / (a + b + 2.0)) {
>>>              ret = 1.0 - regularizedBeta(1.0 - x, b, a, epsilon, maxIterations);
>>> @@ -160,9 +163,9 @@ public class Beta {
>>>      /**
>>>       * Returns the natural logarithm of the beta function B(a, b).
>>>       *
>>> -     * @param a the a parameter.
>>> -     * @param b the b parameter.
>>> -     * @return log(B(a, b))
>>> +     * @param a Parameter {@code a}.
>>> +     * @param b Parameter {@code b}.
>>> +     * @return log(B(a, b)).
>>>       */
>>>      public static double logBeta(double a, double b) {
>>>          return logBeta(a, b, DEFAULT_EPSILON, Integer.MAX_VALUE);
>>> @@ -177,20 +180,23 @@ public class Beta {
>>>       * Beta Function</a>, equation (1).</li>
>>>       * </ul>
>>>       *
>>> -     * @param a the a parameter.
>>> -     * @param b the b parameter.
>>> +     * @param a Parameter {@code a}.
>>> +     * @param b Parameter {@code b}.
>>>       * @param epsilon When the absolute value of the nth item in the
>>> -     *                series is less than epsilon the approximation ceases
>>> -     *                to calculate further elements in the series.
>>> +     * series is less than epsilon the approximation ceases to calculate
>>> +     * further elements in the series.
>>>       * @param maxIterations Maximum number of "iterations" to complete.
>>> -     * @return log(B(a, b))
>>> +     * @return log(B(a, b)).
>>>       */
>>> -    public static double logBeta(double a, double b, double epsilon,
>>> -        int maxIterations) {
>>> -
>>> +    public static double logBeta(double a, double b,
>>> +                                 double epsilon,
>>> +                                 int maxIterations) {
>>>          double ret;
>>>  
>>> -        if (Double.isNaN(a) || Double.isNaN(b) || (a <= 0.0) || (b <= 0.0)) {
>>> +        if (Double.isNaN(a) ||
>>> +            Double.isNaN(b) ||
>>> +            a <= 0.0 ||
>>> +            b <= 0.0) {
>>>              ret = Double.NaN;
>>>          } else {
>>>              ret = Gamma.logGamma(a) + Gamma.logGamma(b) -
>>>
>>> Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Erf.java
>>> URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Erf.java?rev=1083323&r1=1083322&r2=1083323&view=diff
>>> ==============================================================================
>>> --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Erf.java (original)
>>> +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Erf.java Sat Mar 19 22:49:59 2011
>>> @@ -16,7 +16,6 @@
>>>   */
>>>  package org.apache.commons.math.special;
>>>  
>>> -import org.apache.commons.math.MathException;
>>>  import org.apache.commons.math.util.FastMath;
>>>  
>>>  /**
>>> @@ -26,32 +25,32 @@ import org.apache.commons.math.util.Fast
>>>   * @version $Revision$ $Date$
>>>   */
>>>  public class Erf {
>>> -
>>>      /**
>>>       * Default constructor.  Prohibit instantiation.
>>>       */
>>> -    private Erf() {
>>> -        super();
>>> -    }
>>> +    private Erf() {}
>>>  
>>>      /**
>>> -     * <p>Returns the error function</p>
>>> +     * Returns the error function.
>>> +     *
>>>       * <p>erf(x) = 2/&radic;&pi; <sub>0</sub>&int;<sup>x</sup> e<sup>-t<sup>2</sup></sup>dt </p>
>>>       *
>>>       * <p>This implementation computes erf(x) using the
>>>       * {@link Gamma#regularizedGammaP(double, double, double, int) regularized gamma function},
>>>       * following <a href="http://mathworld.wolfram.com/Erf.html"> Erf</a>, equation (3)</p>
>>>       *
>>> -     * <p>The value returned is always between -1 and 1 (inclusive).  If {@code abs(x) > 40}, then
>>> -     * {@code erf(x)} is indistinguishable from either 1 or -1 as a double, so the appropriate extreme
>>> -     * value is returned.</p>
>>> +     * <p>The value returned is always between -1 and 1 (inclusive).
>>> +     * If {@code abs(x) > 40}, then {@code erf(x)} is indistinguishable from
>>> +     * either 1 or -1 as a double, so the appropriate extreme value is returned.
>>> +     * </p>
>>>       *
>>>       * @param x the value.
>>>       * @return the error function erf(x)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @throws org.apache.commons.math.exception.MaxCountExceededException
>>> +     * if the algorithm fails to converge.
>>>       * @see Gamma#regularizedGammaP(double, double, double, int)
>>>       */
>>> -    public static double erf(double x) throws MathException {
>>> +    public static double erf(double x) {
>>>          if (FastMath.abs(x) > 40) {
>>>              return x > 0 ? 1 : -1;
>>>          }
>>> @@ -63,25 +62,29 @@ public class Erf {
>>>      }
>>>  
>>>      /**
>>> -     * <p>Returns the complementary error function</p>
>>> -     * <p>erfc(x) = 2/&radic;&pi; <sub>x</sub>&int;<sup>&infin;</sup> e<sup>-t<sup>2</sup></sup>dt <br/>
>>> +     * Returns the complementary error function.
>>> +     *
>>> +     * <p>erfc(x) = 2/&radic;&pi; <sub>x</sub>&int;<sup>&infin;</sup> e<sup>-t<sup>2</sup></sup>dt
>>> +     * <br/>
>>>       *    = 1 - {@link #erf(double) erf(x)} </p>
>>>       *
>>>       * <p>This implementation computes erfc(x) using the
>>>       * {@link Gamma#regularizedGammaQ(double, double, double, int) regularized gamma function},
>>>       * following <a href="http://mathworld.wolfram.com/Erf.html"> Erf</a>, equation (3).</p>
>>>       *
>>> -     * <p>The value returned is always between 0 and 2 (inclusive).  If {@code abs(x) > 40}, then
>>> -     * {@code erf(x)} is indistinguishable from either 0 or 2 as a double, so the appropriate extreme
>>> -     * value is returned.</p>
>>> +     * <p>The value returned is always between 0 and 2 (inclusive).
>>> +     * If {@code abs(x) > 40}, then {@code erf(x)} is indistinguishable from
>>> +     * either 0 or 2 as a double, so the appropriate extreme value is returned.
>>> +     * </p>
>>>       *
>>>       * @param x the value
>>>       * @return the complementary error function erfc(x)
>>> -     * @throws MathException if the algorithm fails to converge
>>> +     * @throws org.apache.commons.math.exception.MaxCountExceededException
>>> +     * if the algorithm fails to converge.
>>>       * @see Gamma#regularizedGammaQ(double, double, double, int)
>>>       * @since 2.2
>>>       */
>>> -    public static double erfc(double x) throws MathException {
>>> +    public static double erfc(double x) {
>>>          if (FastMath.abs(x) > 40) {
>>>              return x > 0 ? 0 : 2;
>>>          }
>>>
>>> Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Gamma.java
>>> URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Gamma.java?rev=1083323&r1=1083322&r2=1083323&view=diff
>>> ==============================================================================
>>> --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Gamma.java (original)
>>> +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/Gamma.java Sat Mar 19 22:49:59 2011
>>> @@ -16,7 +16,6 @@
>>>   */
>>>  package org.apache.commons.math.special;
>>>  
>>> -import org.apache.commons.math.MathException;
>>>  import org.apache.commons.math.exception.MaxCountExceededException;
>>>  import org.apache.commons.math.util.ContinuedFraction;
>>>  import org.apache.commons.math.util.FastMath;
>>> @@ -28,19 +27,15 @@ import org.apache.commons.math.util.Fast
>>>   * @version $Revision$ $Date$
>>>   */
>>>  public class Gamma {
>>> -
>>>      /**
>>>       * <a href="http://en.wikipedia.org/wiki/Euler-Mascheroni_constant">Euler-Mascheroni constant</a>
>>>       * @since 2.0
>>>       */
>>>      public static final double GAMMA = 0.577215664901532860606512090082;
>>> -
>>>      /** Maximum allowed numerical error. */
>>>      private static final double DEFAULT_EPSILON = 10e-15;
>>> -
>>>      /** Lanczos coefficients */
>>> -    private static final double[] LANCZOS =
>>> -    {
>>> +    private static final double[] LANCZOS = {
>>>          0.99999999999999709182,
>>>          57.156235665862923517,
>>>          -59.597960355475491248,
>>> @@ -57,23 +52,18 @@ public class Gamma {
>>>          -.26190838401581408670e-4,
>>>          .36899182659531622704e-5,
>>>      };
>>> -
>>>      /** Avoid repeated computation of log of 2 PI in logGamma */
>>>      private static final double HALF_LOG_2_PI = 0.5 * FastMath.log(2.0 * FastMath.PI);
>>> -
>>>      // limits for switching algorithm in digamma
>>>      /** C limit. */
>>>      private static final double C_LIMIT = 49;
>>> -
>>>      /** S limit. */
>>>      private static final double S_LIMIT = 1e-5;
>>>  
>>>      /**
>>>       * Default constructor.  Prohibit instantiation.
>>>       */
>>> -    private Gamma() {
>>> -        super();
>>> -    }
>>> +    private Gamma() {}
>>>  
>>>      /**
>>>       * Returns the natural logarithm of the gamma function &#915;(x).
>>> @@ -89,7 +79,7 @@ public class Gamma {
>>>       * </a></li>
>>>       * </ul>
>>>       *
>>> -     * @param x the value.
>>> +     * @param x Value.
>>>       * @return log(&#915;(x))
>>>       */
>>>      public static double logGamma(double x) {
>>> @@ -117,50 +107,47 @@ public class Gamma {
>>>      /**
>>>       * Returns the regularized gamma function P(a, x).
>>>       *
>>> -     * @param a the a parameter.
>>> -     * @param x the value.
>>> -     * @return the regularized gamma function P(a, x)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @param a Parameter.
>>> +     * @param x Value.
>>> +     * @return the regularized gamma function P(a, x).
>>> +     * @throws MaxCountExceededException if the algorithm fails to converge.
>>>       */
>>> -    public static double regularizedGammaP(double a, double x)
>>> -        throws MathException
>>> -    {
>>> +    public static double regularizedGammaP(double a, double x) {
>>>          return regularizedGammaP(a, x, DEFAULT_EPSILON, Integer.MAX_VALUE);
>>>      }
>>>  
>>> -
>>>      /**
>>>       * Returns the regularized gamma function P(a, x).
>>>       *
>>>       * The implementation of this method is based on:
>>>       * <ul>
>>> -     * <li>
>>> -     * <a href="http://mathworld.wolfram.com/RegularizedGammaFunction.html">
>>> -     * Regularized Gamma Function</a>, equation (1).</li>
>>> -     * <li>
>>> -     * <a href="http://mathworld.wolfram.com/IncompleteGammaFunction.html">
>>> -     * Incomplete Gamma Function</a>, equation (4).</li>
>>> -     * <li>
>>> -     * <a href="http://mathworld.wolfram.com/ConfluentHypergeometricFunctionoftheFirstKind.html">
>>> -     * Confluent Hypergeometric Function of the First Kind</a>, equation (1).
>>> -     * </li>
>>> +     *  <li>
>>> +     *   <a href="http://mathworld.wolfram.com/RegularizedGammaFunction.html">
>>> +     *   Regularized Gamma Function</a>, equation (1)
>>> +     *  </li>
>>> +     *  <li>
>>> +     *   <a href="http://mathworld.wolfram.com/IncompleteGammaFunction.html">
>>> +     *   Incomplete Gamma Function</a>, equation (4).
>>> +     *  </li>
>>> +     *  <li>
>>> +     *   <a href="http://mathworld.wolfram.com/ConfluentHypergeometricFunctionoftheFirstKind.html">
>>> +     *   Confluent Hypergeometric Function of the First Kind</a>, equation (1).
>>> +     *  </li>
>>>       * </ul>
>>>       *
>>>       * @param a the a parameter.
>>>       * @param x the value.
>>>       * @param epsilon When the absolute value of the nth item in the
>>> -     *                series is less than epsilon the approximation ceases
>>> -     *                to calculate further elements in the series.
>>> +     * series is less than epsilon the approximation ceases to calculate
>>> +     * further elements in the series.
>>>       * @param maxIterations Maximum number of "iterations" to complete.
>>>       * @return the regularized gamma function P(a, x)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @throws MaxCountExceededException if the algorithm fails to converge.
>>>       */
>>>      public static double regularizedGammaP(double a,
>>>                                             double x,
>>>                                             double epsilon,
>>> -                                           int maxIterations)
>>> -        throws MathException
>>> -    {
>>> +                                           int maxIterations) {
>>>          double ret;
>>>  
>>>          if (Double.isNaN(a) || Double.isNaN(x) || (a <= 0.0) || (x < 0.0)) {
>>> @@ -176,7 +163,9 @@ public class Gamma {
>>>              double n = 0.0; // current element index
>>>              double an = 1.0 / a; // n-th element in the series
>>>              double sum = an; // partial sum
>>> -            while (FastMath.abs(an/sum) > epsilon && n < maxIterations && sum < Double.POSITIVE_INFINITY) {
>>> +            while (FastMath.abs(an/sum) > epsilon &&
>>> +                   n < maxIterations &&
>>> +                   sum < Double.POSITIVE_INFINITY) {
>>>                  // compute next element in the series
>>>                  n = n + 1.0;
>>>                  an = an * (x / (a + n));
>>> @@ -204,9 +193,7 @@ public class Gamma {
>>>       * @return the regularized gamma function Q(a, x)
>>>       * @throws MathException if the algorithm fails to converge.
>>>       */
>>> -    public static double regularizedGammaQ(double a, double x)
>>> -        throws MathException
>>> -    {
>>> +    public static double regularizedGammaQ(double a, double x) {
>>>          return regularizedGammaQ(a, x, DEFAULT_EPSILON, Integer.MAX_VALUE);
>>>      }
>>>  
>>> @@ -215,29 +202,30 @@ public class Gamma {
>>>       *
>>>       * The implementation of this method is based on:
>>>       * <ul>
>>> -     * <li>
>>> -     * <a href="http://mathworld.wolfram.com/RegularizedGammaFunction.html">
>>> -     * Regularized Gamma Function</a>, equation (1).</li>
>>> -     * <li>
>>> -     * <a href="http://functions.wolfram.com/GammaBetaErf/GammaRegularized/10/0003/">
>>> -     * Regularized incomplete gamma function: Continued fraction representations  (formula 06.08.10.0003)</a></li>
>>> +     *  <li>
>>> +     *   <a href="http://mathworld.wolfram.com/RegularizedGammaFunction.html">
>>> +     *   Regularized Gamma Function</a>, equation (1).
>>> +     *  </li>
>>> +     *  <li>
>>> +     *   <a href="http://functions.wolfram.com/GammaBetaErf/GammaRegularized/10/0003/">
>>> +     *   Regularized incomplete gamma function: Continued fraction representations
>>> +     *   (formula 06.08.10.0003)</a>
>>> +     *  </li>
>>>       * </ul>
>>>       *
>>>       * @param a the a parameter.
>>>       * @param x the value.
>>>       * @param epsilon When the absolute value of the nth item in the
>>> -     *                series is less than epsilon the approximation ceases
>>> -     *                to calculate further elements in the series.
>>> +     * series is less than epsilon the approximation ceases to calculate
>>> +     * further elements in the series.
>>>       * @param maxIterations Maximum number of "iterations" to complete.
>>>       * @return the regularized gamma function P(a, x)
>>> -     * @throws MathException if the algorithm fails to converge.
>>> +     * @throws MaxCountExceededException if the algorithm fails to converge.
>>>       */
>>>      public static double regularizedGammaQ(final double a,
>>>                                             double x,
>>>                                             double epsilon,
>>> -                                           int maxIterations)
>>> -        throws MathException
>>> -    {
>>> +                                           int maxIterations) {
>>>          double ret;
>>>  
>>>          if (Double.isNaN(a) || Double.isNaN(x) || (a <= 0.0) || (x < 0.0)) {
>>> @@ -285,10 +273,10 @@ public class Gamma {
>>>       * |x|).  Accuracy for negative values of x should be about 10^-8 absolute for results
>>>       * less than 10^5 and 10^-8 relative for results larger than that.</p>
>>>       *
>>> -     * @param x  the argument
>>> -     * @return   digamma(x) to within 10-8 relative or absolute error whichever is smaller
>>> -     * @see <a href="http://en.wikipedia.org/wiki/Digamma_function"> Digamma at wikipedia </a>
>>> -     * @see <a href="http://www.uv.es/~bernardo/1976AppStatist.pdf"> Bernardo&apos;s original article </a>
>>> +     * @param x Argument.
>>> +     * @return digamma(x) to within 10-8 relative or absolute error whichever is smaller.
>>> +     * @see <a href="http://en.wikipedia.org/wiki/Digamma_function">Digamma</a>
>>> +     * @see <a href="http://www.uv.es/~bernardo/1976AppStatist.pdf">Bernardo&apos;s original article </a>
>>>       * @since 2.0
>>>       */
>>>      public static double digamma(double x) {
>>> @@ -311,12 +299,13 @@ public class Gamma {
>>>      }
>>>  
>>>      /**
>>> -     * <p>Computes the trigamma function of x.  This function is derived by taking the derivative of
>>> -     * the implementation of digamma.</p>
>>> -     *
>>> -     * @param x  the argument
>>> -     * @return   trigamma(x) to within 10-8 relative or absolute error whichever is smaller
>>> -     * @see <a href="http://en.wikipedia.org/wiki/Trigamma_function"> Trigamma at wikipedia </a>
>>> +     * Computes the trigamma function of x.
>>> +     * This function is derived by taking the derivative of the implementation
>>> +     * of digamma.
>>> +     *
>>> +     * @param x Argument.
>>> +     * @return trigamma(x) to within 10-8 relative or absolute error whichever is smaller
>>> +     * @see <a href="http://en.wikipedia.org/wiki/Trigamma_function">Trigamma</a>
>>>       * @see Gamma#digamma(double)
>>>       * @since 2.0
>>>       */
>>>
>>> Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/BetaTest.java
>>> URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/BetaTest.java?rev=1083323&r1=1083322&r2=1083323&view=diff
>>> ==============================================================================
>>> --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/BetaTest.java (original)
>>> +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/BetaTest.java Sat Mar 19 22:49:59 2011
>>> @@ -16,32 +16,19 @@
>>>   */
>>>  package org.apache.commons.math.special;
>>>  
>>> -import org.apache.commons.math.MathException;
>>>  import org.apache.commons.math.TestUtils;
>>>  
>>> -import junit.framework.TestCase;
>>> +import org.junit.Test;
>>> +import org.junit.Assert;
>>>  
>>>  /**
>>>   * @version $Revision$ $Date$
>>>   */
>>> -public class BetaTest extends TestCase {
>>> -    /**
>>> -     * Constructor for BetaTest.
>>> -     * @param name
>>> -     */
>>> -    public BetaTest(String name) {
>>> -        super(name);
>>> -    }
>>> -
>>> -    private void testRegularizedBeta(double expected, double x, double a,
>>> -        double b)
>>> -    {
>>> -        try {
>>> -            double actual = Beta.regularizedBeta(x, a, b);
>>> -            TestUtils.assertEquals(expected, actual, 10e-15);
>>> -        } catch(MathException ex){
>>> -            fail(ex.getMessage());
>>> -        }
>>> +public class BetaTest {
>>> +    private void testRegularizedBeta(double expected, double x,
>>> +                                     double a, double b) {
>>> +        double actual = Beta.regularizedBeta(x, a, b);
>>> +        TestUtils.assertEquals(expected, actual, 10e-15);
>>>      }
>>>  
>>>      private void testLogBeta(double expected, double a, double b) {
>>> @@ -49,70 +36,87 @@ public class BetaTest extends TestCase {
>>>          TestUtils.assertEquals(expected, actual, 10e-15);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaNanPositivePositive() {
>>>          testRegularizedBeta(Double.NaN, Double.NaN, 1.0, 1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositiveNanPositive() {
>>>          testRegularizedBeta(Double.NaN, 0.5, Double.NaN, 1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositivePositiveNan() {
>>>          testRegularizedBeta(Double.NaN, 0.5, 1.0, Double.NaN);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaNegativePositivePositive() {
>>>          testRegularizedBeta(Double.NaN, -0.5, 1.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositiveNegativePositive() {
>>>          testRegularizedBeta(Double.NaN, 0.5, -1.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositivePositiveNegative() {
>>>          testRegularizedBeta(Double.NaN, 0.5, 1.0, -2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaZeroPositivePositive() {
>>>          testRegularizedBeta(0.0, 0.0, 1.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositiveZeroPositive() {
>>>          testRegularizedBeta(Double.NaN, 0.5, 0.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositivePositiveZero() {
>>>          testRegularizedBeta(Double.NaN, 0.5, 1.0, 0.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedBetaPositivePositivePositive() {
>>>          testRegularizedBeta(0.75, 0.5, 1.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaNanPositive() {
>>>          testLogBeta(Double.NaN, Double.NaN, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaPositiveNan() {
>>>          testLogBeta(Double.NaN, 1.0, Double.NaN);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaNegativePositive() {
>>>          testLogBeta(Double.NaN, -1.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaPositiveNegative() {
>>>          testLogBeta(Double.NaN, 1.0, -2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaZeroPositive() {
>>>          testLogBeta(Double.NaN, 0.0, 2.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaPositiveZero() {
>>>          testLogBeta(Double.NaN, 1.0, 0.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogBetaPositivePositive() {
>>>          testLogBeta(-0.693147180559945, 1.0, 2.0);
>>>      }
>>>
>>> Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/ErfTest.java
>>> URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/ErfTest.java?rev=1083323&r1=1083322&r2=1083323&view=diff
>>> ==============================================================================
>>> --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/ErfTest.java (original)
>>> +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/ErfTest.java Sat Mar 19 22:49:59 2011
>>> @@ -17,104 +17,110 @@
>>>  
>>>  package org.apache.commons.math.special;
>>>  
>>> -import org.apache.commons.math.MathException;
>>>  import org.apache.commons.math.TestUtils;
>>>  import org.apache.commons.math.util.FastMath;
>>>  
>>> -import junit.framework.TestCase;
>>> +import org.junit.Test;
>>> +import org.junit.Assert;
>>>  
>>>  /**
>>>   * @version $Revision$ $Date$
>>>   */
>>> -public class ErfTest extends TestCase {
>>> -
>>> -    public void testErf0() throws MathException {
>>> +public class ErfTest {
>>> +    @Test
>>> +    public void testErf0() {
>>>          double actual = Erf.erf(0.0);
>>>          double expected = 0.0;
>>> -        assertEquals(expected, actual, 1.0e-15);
>>> -        assertEquals(1 - expected, Erf.erfc(0.0), 1.0e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-15);
>>> +        Assert.assertEquals(1 - expected, Erf.erfc(0.0), 1.0e-15);
>>>      }
>>>  
>>> -    public void testErf1960() throws MathException {
>>> +    @Test
>>> +    public void testErf1960() {
>>>          double x = 1.960 / FastMath.sqrt(2.0);
>>>          double actual = Erf.erf(x);
>>>          double expected = 0.95;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - actual, Erf.erfc(x), 1.0e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - actual, Erf.erfc(x), 1.0e-15);
>>>  
>>>          actual = Erf.erf(-x);
>>>          expected = -expected;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - actual, Erf.erfc(-x), 1.0e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - actual, Erf.erfc(-x), 1.0e-15);
>>>      }
>>>  
>>> -    public void testErf2576() throws MathException {
>>> +    @Test
>>> +    public void testErf2576() {
>>>          double x = 2.576 / FastMath.sqrt(2.0);
>>>          double actual = Erf.erf(x);
>>>          double expected = 0.99;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - actual, Erf.erfc(x), 1e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - actual, Erf.erfc(x), 1e-15);
>>>  
>>>          actual = Erf.erf(-x);
>>>          expected = -expected;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - actual, Erf.erfc(-x), 1.0e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - actual, Erf.erfc(-x), 1.0e-15);
>>>      }
>>>  
>>> -    public void testErf2807() throws MathException {
>>> +    @Test
>>> +    public void testErf2807() {
>>>          double x = 2.807 / FastMath.sqrt(2.0);
>>>          double actual = Erf.erf(x);
>>>          double expected = 0.995;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - actual, Erf.erfc(x), 1.0e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - actual, Erf.erfc(x), 1.0e-15);
>>>  
>>>          actual = Erf.erf(-x);
>>>          expected = -expected;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - actual, Erf.erfc(-x), 1.0e-15);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - actual, Erf.erfc(-x), 1.0e-15);
>>>      }
>>>  
>>> -    public void testErf3291() throws MathException {
>>> +    @Test
>>> +    public void testErf3291() {
>>>          double x = 3.291 / FastMath.sqrt(2.0);
>>>          double actual = Erf.erf(x);
>>>          double expected = 0.999;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - expected, Erf.erfc(x), 1.0e-5);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - expected, Erf.erfc(x), 1.0e-5);
>>>  
>>>          actual = Erf.erf(-x);
>>>          expected = -expected;
>>> -        assertEquals(expected, actual, 1.0e-5);
>>> -        assertEquals(1 - expected, Erf.erfc(-x), 1.0e-5);
>>> +        Assert.assertEquals(expected, actual, 1.0e-5);
>>> +        Assert.assertEquals(1 - expected, Erf.erfc(-x), 1.0e-5);
>>>      }
>>>      
>>>      /**
>>>       * MATH-301, MATH-456
>>>       */
>>> +    @Test
>>>      public void testLargeValues() throws Exception {
>>>          for (int i = 1; i < 200; i*=10) {
>>>              double result = Erf.erf(i);
>>> -            assertFalse(Double.isNaN(result));
>>> -            assertTrue(result > 0 && result <= 1);
>>> +            Assert.assertFalse(Double.isNaN(result));
>>> +            Assert.assertTrue(result > 0 && result <= 1);
>>>              result = Erf.erf(-i);
>>> -            assertFalse(Double.isNaN(result));
>>> -            assertTrue(result >= -1 && result < 0);
>>> +            Assert.assertFalse(Double.isNaN(result));
>>> +            Assert.assertTrue(result >= -1 && result < 0);
>>>              result = Erf.erfc(i);
>>> -            assertFalse(Double.isNaN(result));
>>> -            assertTrue(result >= 0 && result < 1);
>>> +            Assert.assertFalse(Double.isNaN(result));
>>> +            Assert.assertTrue(result >= 0 && result < 1);
>>>              result = Erf.erfc(-i);
>>> -            assertFalse(Double.isNaN(result));
>>> -            assertTrue(result >= 1 && result <= 2);    
>>> +            Assert.assertFalse(Double.isNaN(result));
>>> +            Assert.assertTrue(result >= 1 && result <= 2);    
>>>          }
>>> -        assertEquals(-1, Erf.erf(Double.NEGATIVE_INFINITY), 0);
>>> -        assertEquals(1, Erf.erf(Double.POSITIVE_INFINITY), 0);
>>> -        assertEquals(2, Erf.erfc(Double.NEGATIVE_INFINITY), 0);
>>> -        assertEquals(0, Erf.erfc(Double.POSITIVE_INFINITY), 0);
>>> +        Assert.assertEquals(-1, Erf.erf(Double.NEGATIVE_INFINITY), 0);
>>> +        Assert.assertEquals(1, Erf.erf(Double.POSITIVE_INFINITY), 0);
>>> +        Assert.assertEquals(2, Erf.erfc(Double.NEGATIVE_INFINITY), 0);
>>> +        Assert.assertEquals(0, Erf.erfc(Double.POSITIVE_INFINITY), 0);
>>>      }
>>>      
>>>      /**
>>>       * Compare Erf.erf against reference values computed using GCC 4.2.1 (Apple OSX packaged version)
>>>       * erfl (extended precision erf).
>>>       */
>>> +    @Test
>>>      public void testErfGnu() throws Exception {
>>>          final double tol = 1E-15;
>>>          final double[] gnuValues = new double[] {-1, -1, -1, -1, -1, 
>>> @@ -129,7 +135,7 @@ public class ErfTest extends TestCase {
>>>           1,  1,  1,  1};
>>>          double x = -10d;
>>>          for (int i = 0; i < 41; i++) {
>>> -            assertEquals(gnuValues[i], Erf.erf(x), tol);
>>> +            Assert.assertEquals(gnuValues[i], Erf.erf(x), tol);
>>>              x += 0.5d;
>>>          }
>>>      }
>>> @@ -138,6 +144,7 @@ public class ErfTest extends TestCase {
>>>       * Compare Erf.erfc against reference values computed using GCC 4.2.1 (Apple OSX packaged version)
>>>       * erfcl (extended precision erfc).
>>>       */
>>> +    @Test
>>>      public void testErfcGnu() throws Exception {
>>>          final double tol = 1E-15;
>>>          final double[] gnuValues = new double[] { 2,  2,  2,  2,  2, 
>>> @@ -152,7 +159,7 @@ public class ErfTest extends TestCase {
>>>          2.7623240713337714448E-33, 4.1370317465138102353E-37, 3.7692144856548799402E-41, 2.0884875837625447567E-45};
>>>          double x = -10d;
>>>          for (int i = 0; i < 41; i++) {
>>> -            assertEquals(gnuValues[i], Erf.erfc(x), tol);
>>> +            Assert.assertEquals(gnuValues[i], Erf.erfc(x), tol);
>>>              x += 0.5d;
>>>          }
>>>      }
>>> @@ -162,6 +169,7 @@ public class ErfTest extends TestCase {
>>>       * "Evaluating the Normal Distribution," Journal of Statistical Software, July, 2004.
>>>       * http//www.jstatsoft.org/v11/a05/paper
>>>       */
>>> +    @Test
>>>      public void testErfcMaple() throws Exception {
>>>          double[][] ref = new double[][]
>>>                          {{0.1, 4.60172162722971e-01},
>>> @@ -183,7 +191,7 @@ public class ErfTest extends TestCase {
>>>          };
>>>          for (int i = 0; i < 15; i++) {
>>>              final double result = 0.5*Erf.erfc(ref[i][0]/Math.sqrt(2));
>>> -            assertEquals(ref[i][1], result, 1E-15);
>>> +            Assert.assertEquals(ref[i][1], result, 1E-15);
>>>              TestUtils.assertRelativelyEquals(ref[i][1], result, 1E-13);
>>>          }
>>>      }
>>>
>>> Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/GammaTest.java
>>> URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/GammaTest.java?rev=1083323&r1=1083322&r2=1083323&view=diff
>>> ==============================================================================
>>> --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/GammaTest.java (original)
>>> +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/special/GammaTest.java Sat Mar 19 22:49:59 2011
>>> @@ -16,30 +16,21 @@
>>>   */
>>>  package org.apache.commons.math.special;
>>>  
>>> -import org.apache.commons.math.MathException;
>>>  import org.apache.commons.math.TestUtils;
>>>  import org.apache.commons.math.util.FastMath;
>>>  
>>> -import junit.framework.TestCase;
>>> +import org.junit.Test;
>>> +import org.junit.Assert;
>>>  
>>>  /**
>>>   * @version $Revision$ $Date$
>>>   */
>>> -public class GammaTest extends TestCase {
>>> -
>>> -    public GammaTest(String name) {
>>> -        super(name);
>>> -    }
>>> -
>>> +public class GammaTest {
>>>      private void testRegularizedGamma(double expected, double a, double x) {
>>> -        try {
>>> -            double actualP = Gamma.regularizedGammaP(a, x);
>>> -            double actualQ = Gamma.regularizedGammaQ(a, x);
>>> -            TestUtils.assertEquals(expected, actualP, 10e-15);
>>> -            TestUtils.assertEquals(actualP, 1.0 - actualQ, 10e-15);
>>> -        } catch(MathException ex){
>>> -            fail(ex.getMessage());
>>> -        }
>>> +        double actualP = Gamma.regularizedGammaP(a, x);
>>> +        double actualQ = Gamma.regularizedGammaQ(a, x);
>>> +        TestUtils.assertEquals(expected, actualP, 10e-15);
>>> +        TestUtils.assertEquals(actualP, 1.0 - actualQ, 10e-15);
>>>      }
>>>  
>>>      private void testLogGamma(double expected, double x) {
>>> @@ -47,65 +38,78 @@ public class GammaTest extends TestCase 
>>>          TestUtils.assertEquals(expected, actual, 10e-15);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaNanPositive() {
>>>          testRegularizedGamma(Double.NaN, Double.NaN, 1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaPositiveNan() {
>>>          testRegularizedGamma(Double.NaN, 1.0, Double.NaN);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaNegativePositive() {
>>>          testRegularizedGamma(Double.NaN, -1.5, 1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaPositiveNegative() {
>>>          testRegularizedGamma(Double.NaN, 1.0, -1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaZeroPositive() {
>>>          testRegularizedGamma(Double.NaN, 0.0, 1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaPositiveZero() {
>>>          testRegularizedGamma(0.0, 1.0, 0.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testRegularizedGammaPositivePositive() {
>>>          testRegularizedGamma(0.632120558828558, 1.0, 1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogGammaNan() {
>>>          testLogGamma(Double.NaN, Double.NaN);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogGammaNegative() {
>>>          testLogGamma(Double.NaN, -1.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogGammaZero() {
>>>          testLogGamma(Double.NaN, 0.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testLogGammaPositive() {
>>>          testLogGamma(0.6931471805599457, 3.0);
>>>      }
>>>  
>>> +    @Test
>>>      public void testDigammaLargeArgs() {
>>>          double eps = 1e-8;
>>> -        assertEquals(4.6001618527380874002, Gamma.digamma(100), eps);
>>> -        assertEquals(3.9019896734278921970, Gamma.digamma(50), eps);
>>> -        assertEquals(2.9705239922421490509, Gamma.digamma(20), eps);
>>> -        assertEquals(2.9958363947076465821, Gamma.digamma(20.5), eps);
>>> -        assertEquals(2.2622143570941481605, Gamma.digamma(10.1), eps);
>>> -        assertEquals(2.1168588189004379233, Gamma.digamma(8.8), eps);
>>> -        assertEquals(1.8727843350984671394, Gamma.digamma(7), eps);
>>> -        assertEquals(0.42278433509846713939, Gamma.digamma(2), eps);
>>> -        assertEquals(-100.56088545786867450, Gamma.digamma(0.01), eps);
>>> -        assertEquals(-4.0390398965921882955, Gamma.digamma(-0.8), eps);
>>> -        assertEquals(4.2003210041401844726, Gamma.digamma(-6.3), eps);
>>> +        Assert.assertEquals(4.6001618527380874002, Gamma.digamma(100), eps);
>>> +        Assert.assertEquals(3.9019896734278921970, Gamma.digamma(50), eps);
>>> +        Assert.assertEquals(2.9705239922421490509, Gamma.digamma(20), eps);
>>> +        Assert.assertEquals(2.9958363947076465821, Gamma.digamma(20.5), eps);
>>> +        Assert.assertEquals(2.2622143570941481605, Gamma.digamma(10.1), eps);
>>> +        Assert.assertEquals(2.1168588189004379233, Gamma.digamma(8.8), eps);
>>> +        Assert.assertEquals(1.8727843350984671394, Gamma.digamma(7), eps);
>>> +        Assert.assertEquals(0.42278433509846713939, Gamma.digamma(2), eps);
>>> +        Assert.assertEquals(-100.56088545786867450, Gamma.digamma(0.01), eps);
>>> +        Assert.assertEquals(-4.0390398965921882955, Gamma.digamma(-0.8), eps);
>>> +        Assert.assertEquals(4.2003210041401844726, Gamma.digamma(-6.3), eps);
>>>      }
>>>  
>>> +    @Test
>>>      public void testDigammaSmallArgs() {
>>>          // values for negative powers of 10 from 1 to 30 as computed by webMathematica with 20 digits
>>>          // see functions.wolfram.com
>>> @@ -120,6 +124,7 @@ public class GammaTest extends TestCase 
>>>          }
>>>      }
>>>  
>>> +    @Test
>>>      public void testTrigamma() {
>>>          double eps = 1e-8;
>>>          // computed using webMathematica.  For example, to compute trigamma($i) = Polygamma(1, $i), use
>>> @@ -141,11 +146,11 @@ public class GammaTest extends TestCase 
>>>                  100, 0.010050166663333571395
>>>          };
>>>          for (int i = data.length - 2; i >= 0; i -= 2) {
>>> -            assertEquals(String.format("trigamma %.0f", data[i]), data[i + 1], Gamma.trigamma(data[i]), eps);
>>> +            Assert.assertEquals(String.format("trigamma %.0f", data[i]), data[i + 1], Gamma.trigamma(data[i]), eps);
>>>          }
>>>      }
>>>  
>>>      private void checkRelativeError(String msg, double expected, double actual, double tolerance) {
>>> -        assertEquals(msg, expected, actual, FastMath.abs(tolerance * actual));
>>> +        Assert.assertEquals(msg, expected, actual, FastMath.abs(tolerance * actual));
>>>      }
>>>  }
>>>
>>>
>>>
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
>> For additional commands, e-mail: dev-help@commons.apache.org
>>
> 
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
> For additional commands, e-mail: dev-help@commons.apache.org
> 


---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org


Mime
View raw message