Author: erans
Date: Sat Mar 19 22:49:59 2011
New Revision: 1083323
URL: http://svn.apache.org/viewvc?rev=1083323&view=rev
Log:
MATH-446
Removed checked exceptions.
Some Javadoc cleanup.
Tests upgraded to Junit 4 (MATH-423).
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/√π <sub>0</sub>∫<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/√π <sub>x</sub>∫<sup>∞</sup>
e<sup>-t<sup>2</sup></sup>dt <br/>
+ * Returns the complementary error function.
+ *
+ * <p>erfc(x) = 2/√π <sub>x</sub>∫<sup>∞</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 Γ(x).
@@ -89,7 +79,7 @@ public class Gamma {
* </a></li>
* </ul>
*
- * @param x the value.
+ * @param x Value.
* @return log(Γ(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'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'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));
}
}
|