commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Gilles Sadowski <gil...@harfang.homelinux.org>
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 10:12:44 GMT
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.]


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


Mime
View raw message