You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2012/09/05 20:29:47 UTC
svn commit: r1381283 - in
/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util:
ArithmeticUtils.java BigReal.java ContinuedFraction.java MathArrays.java
MathUtils.java MultidimensionalCounter.java Precision.java
ResizableDoubleArray.java
Author: luc
Date: Wed Sep 5 18:29:47 2012
New Revision: 1381283
URL: http://svn.apache.org/viewvc?rev=1381283&view=rev
Log:
Added throw declarations for package util.
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ArithmeticUtils.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/BigReal.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ContinuedFraction.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathUtils.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MultidimensionalCounter.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Precision.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ResizableDoubleArray.java
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ArithmeticUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ArithmeticUtils.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ArithmeticUtils.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ArithmeticUtils.java Wed Sep 5 18:29:47 2012
@@ -61,7 +61,8 @@ public final class ArithmeticUtils {
* as an {@code int}.
* @since 1.1
*/
- public static int addAndCheck(int x, int y) {
+ public static int addAndCheck(int x, int y)
+ throws MathArithmeticException {
long s = (long)x + (long)y;
if (s < Integer.MIN_VALUE || s > Integer.MAX_VALUE) {
throw new MathArithmeticException(LocalizedFormats.OVERFLOW_IN_ADDITION, x, y);
@@ -79,7 +80,7 @@ public final class ArithmeticUtils {
* long
* @since 1.2
*/
- public static long addAndCheck(long a, long b) {
+ public static long addAndCheck(long a, long b) throws MathArithmeticException {
return ArithmeticUtils.addAndCheck(a, b, LocalizedFormats.OVERFLOW_IN_ADDITION);
}
@@ -109,7 +110,8 @@ public final class ArithmeticUtils {
* @throws MathArithmeticException if the result is too large to be
* represented by a long integer.
*/
- public static long binomialCoefficient(final int n, final int k) {
+ public static long binomialCoefficient(final int n, final int k)
+ throws NotPositiveException, NumberIsTooLargeException, MathArithmeticException {
ArithmeticUtils.checkBinomial(n, k);
if ((n == k) || (k == 0)) {
return 1;
@@ -186,8 +188,11 @@ public final class ArithmeticUtils {
* @return {@code n choose k}
* @throws NotPositiveException if {@code n < 0}.
* @throws NumberIsTooLargeException if {@code k > n}.
+ * @throws MathArithmeticException if the result is too large to be
+ * represented by a long integer.
*/
- public static double binomialCoefficientDouble(final int n, final int k) {
+ public static double binomialCoefficientDouble(final int n, final int k)
+ throws NotPositiveException, NumberIsTooLargeException, MathArithmeticException {
ArithmeticUtils.checkBinomial(n, k);
if ((n == k) || (k == 0)) {
return 1d;
@@ -228,8 +233,11 @@ public final class ArithmeticUtils {
* @return {@code n choose k}
* @throws NotPositiveException if {@code n < 0}.
* @throws NumberIsTooLargeException if {@code k > n}.
+ * @throws MathArithmeticException if the result is too large to be
+ * represented by a long integer.
*/
- public static double binomialCoefficientLog(final int n, final int k) {
+ public static double binomialCoefficientLog(final int n, final int k)
+ throws NotPositiveException, NumberIsTooLargeException, MathArithmeticException {
ArithmeticUtils.checkBinomial(n, k);
if ((n == k) || (k == 0)) {
return 0;
@@ -300,7 +308,7 @@ public final class ArithmeticUtils {
* @throws MathArithmeticException if {@code n > 20}: The factorial value is too
* large to fit in a {@code long}.
*/
- public static long factorial(final int n) {
+ public static long factorial(final int n) throws NotPositiveException, MathArithmeticException {
if (n < 0) {
throw new NotPositiveException(LocalizedFormats.FACTORIAL_NEGATIVE_PARAMETER,
n);
@@ -324,13 +332,13 @@ public final class ArithmeticUtils {
* @return {@code n!}
* @throws NotPositiveException if {@code n < 0}.
*/
- public static double factorialDouble(final int n) {
+ public static double factorialDouble(final int n) throws NotPositiveException, MathArithmeticException {
if (n < 0) {
throw new NotPositiveException(LocalizedFormats.FACTORIAL_NEGATIVE_PARAMETER,
n);
}
if (n < 21) {
- return factorial(n);
+ return FACTORIALS[n];
}
return FastMath.floor(FastMath.exp(ArithmeticUtils.factorialLog(n)) + 0.5);
}
@@ -342,13 +350,13 @@ public final class ArithmeticUtils {
* @return {@code n!}
* @throws NotPositiveException if {@code n < 0}.
*/
- public static double factorialLog(final int n) {
+ public static double factorialLog(final int n) throws NotPositiveException {
if (n < 0) {
throw new NotPositiveException(LocalizedFormats.FACTORIAL_NEGATIVE_PARAMETER,
n);
}
if (n < 21) {
- return FastMath.log(factorial(n));
+ return FastMath.log(FACTORIALS[n]);
}
double logSum = 0;
for (int i = 2; i <= n; i++) {
@@ -529,7 +537,7 @@ public final class ArithmeticUtils {
* a non-negative {@code long} value.
* @since 2.1
*/
- public static long gcd(final long p, final long q) {
+ public static long gcd(final long p, final long q) throws MathArithmeticException {
long u = p;
long v = q;
if ((u == 0) || (v == 0)) {
@@ -609,7 +617,7 @@ public final class ArithmeticUtils {
* a non-negative {@code int} value.
* @since 1.1
*/
- public static int lcm(int a, int b) {
+ public static int lcm(int a, int b) throws MathArithmeticException {
if (a == 0 || b == 0){
return 0;
}
@@ -643,7 +651,7 @@ public final class ArithmeticUtils {
* as a non-negative {@code long} value.
* @since 2.1
*/
- public static long lcm(long a, long b) {
+ public static long lcm(long a, long b) throws MathArithmeticException {
if (a == 0 || b == 0){
return 0;
}
@@ -665,7 +673,7 @@ public final class ArithmeticUtils {
* represented as an {@code int}.
* @since 1.1
*/
- public static int mulAndCheck(int x, int y) {
+ public static int mulAndCheck(int x, int y) throws MathArithmeticException {
long m = ((long)x) * ((long)y);
if (m < Integer.MIN_VALUE || m > Integer.MAX_VALUE) {
throw new MathArithmeticException();
@@ -683,7 +691,7 @@ public final class ArithmeticUtils {
* as a {@code long}.
* @since 1.2
*/
- public static long mulAndCheck(long a, long b) {
+ public static long mulAndCheck(long a, long b) throws MathArithmeticException {
long ret;
if (a > b) {
// use symmetry to reduce boundary cases
@@ -737,7 +745,7 @@ public final class ArithmeticUtils {
* as an {@code int}.
* @since 1.1
*/
- public static int subAndCheck(int x, int y) {
+ public static int subAndCheck(int x, int y) throws MathArithmeticException {
long s = (long)x - (long)y;
if (s < Integer.MIN_VALUE || s > Integer.MAX_VALUE) {
throw new MathArithmeticException(LocalizedFormats.OVERFLOW_IN_SUBTRACTION, x, y);
@@ -755,7 +763,7 @@ public final class ArithmeticUtils {
* {@code long}.
* @since 1.2
*/
- public static long subAndCheck(long a, long b) {
+ public static long subAndCheck(long a, long b) throws MathArithmeticException {
long ret;
if (b == Long.MIN_VALUE) {
if (a < 0) {
@@ -778,7 +786,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static int pow(final int k, int e) {
+ public static int pow(final int k, int e) throws NotPositiveException {
if (e < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -804,7 +812,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static int pow(final int k, long e) {
+ public static int pow(final int k, long e) throws NotPositiveException {
if (e < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -830,7 +838,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static long pow(final long k, int e) {
+ public static long pow(final long k, int e) throws NotPositiveException {
if (e < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -856,7 +864,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static long pow(final long k, long e) {
+ public static long pow(final long k, long e) throws NotPositiveException {
if (e < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -882,7 +890,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static BigInteger pow(final BigInteger k, int e) {
+ public static BigInteger pow(final BigInteger k, int e) throws NotPositiveException {
if (e < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -898,7 +906,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static BigInteger pow(final BigInteger k, long e) {
+ public static BigInteger pow(final BigInteger k, long e) throws NotPositiveException {
if (e < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -925,7 +933,7 @@ public final class ArithmeticUtils {
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
- public static BigInteger pow(final BigInteger k, BigInteger e) {
+ public static BigInteger pow(final BigInteger k, BigInteger e) throws NotPositiveException {
if (e.compareTo(BigInteger.ZERO) < 0) {
throw new NotPositiveException(LocalizedFormats.EXPONENT, e);
}
@@ -1039,7 +1047,7 @@ public final class ArithmeticUtils {
* as a {@code long}.
* @since 1.2
*/
- private static long addAndCheck(long a, long b, Localizable pattern) {
+ private static long addAndCheck(long a, long b, Localizable pattern) throws MathArithmeticException {
long ret;
if (a > b) {
// use symmetry to reduce boundary cases
@@ -1082,7 +1090,7 @@ public final class ArithmeticUtils {
* @throws NotPositiveException if {@code n < 0}.
* @throws NumberIsTooLargeException if {@code k > n}.
*/
- private static void checkBinomial(final int n, final int k) {
+ private static void checkBinomial(final int n, final int k) throws NumberIsTooLargeException, NotPositiveException {
if (n < k) {
throw new NumberIsTooLargeException(LocalizedFormats.BINOMIAL_INVALID_PARAMETERS_ORDER,
k, n, true);
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/BigReal.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/BigReal.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/BigReal.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/BigReal.java Wed Sep 5 18:29:47 2012
@@ -248,7 +248,7 @@ public class BigReal implements FieldEle
*
* @throws MathArithmeticException if {@code a} is zero
*/
- public BigReal divide(BigReal a) {
+ public BigReal divide(BigReal a) throws MathArithmeticException {
try {
return new BigReal(d.divide(a.d, scale, roundingMode));
} catch (ArithmeticException e) {
@@ -262,7 +262,7 @@ public class BigReal implements FieldEle
*
* @throws MathArithmeticException if {@code this} is zero
*/
- public BigReal reciprocal() {
+ public BigReal reciprocal() throws MathArithmeticException {
try {
return new BigReal(BigDecimal.ONE.divide(d, scale, roundingMode));
} catch (ArithmeticException e) {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ContinuedFraction.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ContinuedFraction.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ContinuedFraction.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ContinuedFraction.java Wed Sep 5 18:29:47 2012
@@ -17,6 +17,7 @@
package org.apache.commons.math3.util;
import org.apache.commons.math3.exception.ConvergenceException;
+import org.apache.commons.math3.exception.MathInternalError;
import org.apache.commons.math3.exception.MaxCountExceededException;
import org.apache.commons.math3.exception.util.LocalizedFormats;
@@ -69,8 +70,13 @@ public abstract class ContinuedFraction
* @return the value of the continued fraction evaluated at x.
* @throws ConvergenceException if the algorithm fails to converge.
*/
- public double evaluate(double x) {
- return evaluate(x, DEFAULT_EPSILON, Integer.MAX_VALUE);
+ public double evaluate(double x) throws ConvergenceException {
+ try {
+ return evaluate(x, DEFAULT_EPSILON, Integer.MAX_VALUE);
+ } catch (MaxCountExceededException e) {
+ // this should never happen as integers never exceed MAX_VALUE
+ throw new MathInternalError(e);
+ }
}
/**
@@ -80,8 +86,13 @@ public abstract class ContinuedFraction
* @return the value of the continued fraction evaluated at x.
* @throws ConvergenceException if the algorithm fails to converge.
*/
- public double evaluate(double x, double epsilon) {
- return evaluate(x, epsilon, Integer.MAX_VALUE);
+ public double evaluate(double x, double epsilon) throws ConvergenceException {
+ try {
+ return evaluate(x, epsilon, Integer.MAX_VALUE);
+ } catch (MaxCountExceededException e) {
+ // this should never happen as integers never exceed MAX_VALUE
+ throw new MathInternalError(e);
+ }
}
/**
@@ -90,8 +101,10 @@ public abstract class ContinuedFraction
* @param maxIterations maximum number of convergents
* @return the value of the continued fraction evaluated at x.
* @throws ConvergenceException if the algorithm fails to converge.
+ * @throws MaxCountExceededException if maximal number of iterations is reached
*/
- public double evaluate(double x, int maxIterations) {
+ public double evaluate(double x, int maxIterations)
+ throws ConvergenceException, MaxCountExceededException {
return evaluate(x, DEFAULT_EPSILON, maxIterations);
}
@@ -119,8 +132,10 @@ public abstract class ContinuedFraction
* @param maxIterations maximum number of convergents
* @return the value of the continued fraction evaluated at x.
* @throws ConvergenceException if the algorithm fails to converge.
+ * @throws MaxCountExceededException if maximal number of iterations is reached
*/
- public double evaluate(double x, double epsilon, int maxIterations) {
+ public double evaluate(double x, double epsilon, int maxIterations)
+ throws ConvergenceException, MaxCountExceededException {
final double small = 1e-50;
double hPrev = getA(0, x);
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java Wed Sep 5 18:29:47 2012
@@ -209,7 +209,12 @@ public class MathArrays {
public static boolean isMonotonic(double[] val,
OrderDirection dir,
boolean strict) {
- return checkOrder(val, dir, strict, false);
+ try {
+ return checkOrder(val, dir, strict, false);
+ } catch (NonMonotonicSequenceException e) {
+ // this should never happen as abort is set to false
+ throw new MathInternalError(e);
+ }
}
/**
@@ -224,7 +229,8 @@ public class MathArrays {
* and {@code abort} is {@code true}.
*/
public static boolean checkOrder(double[] val, OrderDirection dir,
- boolean strict, boolean abort) {
+ boolean strict, boolean abort)
+ throws NonMonotonicSequenceException {
double previous = val[0];
final int max = val.length;
@@ -285,7 +291,7 @@ public class MathArrays {
* @since 2.2
*/
public static void checkOrder(double[] val, OrderDirection dir,
- boolean strict) {
+ boolean strict) throws NonMonotonicSequenceException {
checkOrder(val, dir, strict, true);
}
@@ -296,7 +302,7 @@ public class MathArrays {
* @throws NonMonotonicSequenceException if the array is not sorted.
* @since 2.2
*/
- public static void checkOrder(double[] val) {
+ public static void checkOrder(double[] val) throws NonMonotonicSequenceException {
checkOrder(val, OrderDirection.INCREASING, true);
}
@@ -431,8 +437,8 @@ public class MathArrays {
* @throws NullArgumentException if {@code x} or any {@code y} is null.
* @since 3.0
*/
- public static void sortInPlace(double[] x,
- double[] ... yList) {
+ public static void sortInPlace(double[] x, double[] ... yList)
+ throws DimensionMismatchException, NullArgumentException {
sortInPlace(x, OrderDirection.INCREASING, yList);
}
@@ -455,7 +461,8 @@ public class MathArrays {
*/
public static void sortInPlace(double[] x,
final OrderDirection dir,
- double[] ... yList) {
+ double[] ... yList)
+ throws NullArgumentException, DimensionMismatchException {
if (x == null) {
throw new NullArgumentException();
}
@@ -577,8 +584,10 @@ public class MathArrays {
* @param a Factors.
* @param b Factors.
* @return <code>Σ<sub>i</sub> a<sub>i</sub> b<sub>i</sub></code>.
+ * @throws DimensionMismatchException if arrays dimensions don't match
*/
- public static double linearCombination(final double[] a, final double[] b) {
+ public static double linearCombination(final double[] a, final double[] b)
+ throws DimensionMismatchException {
final int len = a.length;
if (len != b.length) {
throw new DimensionMismatchException(len, b.length);
@@ -1052,7 +1061,8 @@ public class MathArrays {
* @throws MathIllegalArgumentException if the target sum is infinite or {@code NaN}.
* @since 2.1
*/
- public static double[] normalizeArray(double[] values, double normalizedSum) {
+ public static double[] normalizeArray(double[] values, double normalizedSum)
+ throws MathIllegalArgumentException, MathArithmeticException {
if (Double.isInfinite(normalizedSum)) {
throw new MathIllegalArgumentException(LocalizedFormats.NORMALIZE_INFINITE);
}
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathUtils.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathUtils.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathUtils.java Wed Sep 5 18:29:47 2012
@@ -124,7 +124,8 @@ public final class MathUtils {
* @throws MathArithmeticException if {@code magnitude == Byte.MIN_VALUE}
* and {@code sign >= 0}.
*/
- public static byte copySign(byte magnitude, byte sign) {
+ public static byte copySign(byte magnitude, byte sign)
+ throws MathArithmeticException {
if ((magnitude >= 0 && sign >= 0) ||
(magnitude < 0 && sign < 0)) { // Sign is OK.
return magnitude;
@@ -146,7 +147,8 @@ public final class MathUtils {
* @throws MathArithmeticException if {@code magnitude == Short.MIN_VALUE}
* and {@code sign >= 0}.
*/
- public static short copySign(short magnitude, short sign) {
+ public static short copySign(short magnitude, short sign)
+ throws MathArithmeticException {
if ((magnitude >= 0 && sign >= 0) ||
(magnitude < 0 && sign < 0)) { // Sign is OK.
return magnitude;
@@ -168,7 +170,8 @@ public final class MathUtils {
* @throws MathArithmeticException if {@code magnitude == Integer.MIN_VALUE}
* and {@code sign >= 0}.
*/
- public static int copySign(int magnitude, int sign) {
+ public static int copySign(int magnitude, int sign)
+ throws MathArithmeticException {
if ((magnitude >= 0 && sign >= 0) ||
(magnitude < 0 && sign < 0)) { // Sign is OK.
return magnitude;
@@ -190,7 +193,8 @@ public final class MathUtils {
* @throws MathArithmeticException if {@code magnitude == Long.MIN_VALUE}
* and {@code sign >= 0}.
*/
- public static long copySign(long magnitude, long sign) {
+ public static long copySign(long magnitude, long sign)
+ throws MathArithmeticException {
if ((magnitude >= 0 && sign >= 0) ||
(magnitude < 0 && sign < 0)) { // Sign is OK.
return magnitude;
@@ -208,7 +212,8 @@ public final class MathUtils {
* @throws NotFiniteNumberException if {@code x} is not a
* finite real number.
*/
- public static void checkFinite(final double x) {
+ public static void checkFinite(final double x)
+ throws NotFiniteNumberException {
if (Double.isInfinite(x) || Double.isNaN(x)) {
throw new NotFiniteNumberException(x);
}
@@ -221,7 +226,8 @@ public final class MathUtils {
* @throws NotFiniteNumberException if any values of the array is not a
* finite real number.
*/
- public static void checkFinite(final double[] val) {
+ public static void checkFinite(final double[] val)
+ throws NotFiniteNumberException {
for (int i = 0; i < val.length; i++) {
final double x = val[i];
if (Double.isInfinite(x) || Double.isNaN(x)) {
@@ -240,7 +246,8 @@ public final class MathUtils {
*/
public static void checkNotNull(Object o,
Localizable pattern,
- Object ... args) {
+ Object ... args)
+ throws NullArgumentException {
if (o == null) {
throw new NullArgumentException(pattern, args);
}
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MultidimensionalCounter.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MultidimensionalCounter.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MultidimensionalCounter.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MultidimensionalCounter.java Wed Sep 5 18:29:47 2012
@@ -18,6 +18,7 @@
package org.apache.commons.math3.util;
import org.apache.commons.math3.exception.DimensionMismatchException;
+import org.apache.commons.math3.exception.MathInternalError;
import org.apache.commons.math3.exception.OutOfRangeException;
import org.apache.commons.math3.exception.NotStrictlyPositiveException;
@@ -162,7 +163,7 @@ public class MultidimensionalCounter imp
* @throws NotStrictlyPositiveException if one of the sizes is
* negative or zero.
*/
- public MultidimensionalCounter(int ... size) {
+ public MultidimensionalCounter(int ... size) throws NotStrictlyPositiveException {
dimension = size.length;
this.size = MathArrays.copyOf(size);
@@ -213,7 +214,7 @@ public class MultidimensionalCounter imp
* @throws OutOfRangeException if {@code index} is not between
* {@code 0} and the value returned by {@link #getSize()} (excluded).
*/
- public int[] getCounts(int index) {
+ public int[] getCounts(int index) throws OutOfRangeException {
if (index < 0 ||
index >= totalSize) {
throw new OutOfRangeException(index, 0, totalSize);
@@ -250,7 +251,8 @@ public class MultidimensionalCounter imp
* the range of the corresponding dimension, as defined in the
* {@link MultidimensionalCounter#MultidimensionalCounter(int...) constructor}.
*/
- public int getCount(int ... c) throws OutOfRangeException {
+ public int getCount(int ... c)
+ throws OutOfRangeException, DimensionMismatchException {
if (c.length != dimension) {
throw new DimensionMismatchException(c.length, dimension);
}
@@ -290,7 +292,15 @@ public class MultidimensionalCounter imp
public String toString() {
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < dimension; i++) {
- sb.append("[").append(getCount(i)).append("]");
+ try {
+ sb.append("[").append(getCount(i)).append("]");
+ } catch (OutOfRangeException e) {
+ // this should never happen
+ throw new MathInternalError(e);
+ } catch (DimensionMismatchException e) {
+ // this should never happen
+ throw new MathInternalError(e);
+ }
}
return sb.toString();
}
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Precision.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Precision.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Precision.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Precision.java Wed Sep 5 18:29:47 2012
@@ -20,6 +20,7 @@ package org.apache.commons.math3.util;
import java.math.BigDecimal;
import org.apache.commons.math3.exception.MathArithmeticException;
import org.apache.commons.math3.exception.MathIllegalArgumentException;
+import org.apache.commons.math3.exception.MathInternalError;
import org.apache.commons.math3.exception.util.LocalizedFormats;
/**
@@ -391,7 +392,15 @@ public class Precision {
* @since 1.1 (previously in {@code MathUtils}, moved as of version 3.0)
*/
public static float round(float x, int scale) {
+ try {
return round(x, scale, BigDecimal.ROUND_HALF_UP);
+ } catch (MathArithmeticException e) {
+ // should never happen as we don't use BigDecimal.ROUND_UNNECESSARY
+ throw new MathInternalError(e);
+ } catch (MathIllegalArgumentException e) {
+ // should never happen as we use a valid rounding
+ throw new MathInternalError(e);
+ }
}
/**
@@ -404,8 +413,11 @@ public class Precision {
* @param roundingMethod Rounding method as defined in {@link BigDecimal}.
* @return the rounded value.
* @since 1.1 (previously in {@code MathUtils}, moved as of version 3.0)
+ * @throws MathArithmeticException if an exact operation is required but result is not exact
+ * @throws MathIllegalArgumentException if {@code roundingMethod} is not a valid rounding method.
*/
- public static float round(float x, int scale, int roundingMethod) {
+ public static float round(float x, int scale, int roundingMethod)
+ throws MathArithmeticException, MathIllegalArgumentException {
final float sign = FastMath.copySign(1f, x);
final float factor = (float) FastMath.pow(10.0f, scale) * sign;
return (float) roundUnscaled(x * factor, sign, roundingMethod) / factor;
@@ -420,12 +432,14 @@ public class Precision {
* @param sign Sign of the original, scaled value.
* @param roundingMethod Rounding method, as defined in {@link BigDecimal}.
* @return the rounded value.
+ * @throws MathArithmeticException if an exact operation is required but result is not exact
* @throws MathIllegalArgumentException if {@code roundingMethod} is not a valid rounding method.
* @since 1.1 (previously in {@code MathUtils}, moved as of version 3.0)
*/
private static double roundUnscaled(double unscaled,
double sign,
- int roundingMethod) {
+ int roundingMethod)
+ throws MathArithmeticException, MathIllegalArgumentException {
switch (roundingMethod) {
case BigDecimal.ROUND_CEILING :
if (sign == -1) {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ResizableDoubleArray.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ResizableDoubleArray.java?rev=1381283&r1=1381282&r2=1381283&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ResizableDoubleArray.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/ResizableDoubleArray.java Wed Sep 5 18:29:47 2012
@@ -21,6 +21,7 @@ import java.util.Arrays;
import org.apache.commons.math3.exception.MathIllegalArgumentException;
import org.apache.commons.math3.exception.MathIllegalStateException;
+import org.apache.commons.math3.exception.MathInternalError;
import org.apache.commons.math3.exception.NullArgumentException;
import org.apache.commons.math3.exception.util.LocalizedFormats;
@@ -155,9 +156,9 @@ public class ResizableDoubleArray implem
* <li><code>contractionFactor = 2.0</code></li>
* </ul>
* @param initialCapacity The initial size of the internal storage array
- * @throws IllegalArgumentException if initialCapacity is not > 0
+ * @throws MathIllegalArgumentException if initialCapacity is not > 0
*/
- public ResizableDoubleArray(int initialCapacity) {
+ public ResizableDoubleArray(int initialCapacity) throws MathIllegalArgumentException {
setInitialCapacity(initialCapacity);
internalArray = new double[this.initialCapacity];
}
@@ -210,9 +211,9 @@ public class ResizableDoubleArray implem
* @param initialCapacity The initial size of the internal storage array
* @param expansionFactor the array will be expanded based on this
* parameter
- * @throws IllegalArgumentException if parameters are not valid
+ * @throws MathIllegalArgumentException if parameters are not valid
*/
- public ResizableDoubleArray(int initialCapacity, float expansionFactor) {
+ public ResizableDoubleArray(int initialCapacity, float expansionFactor) throws MathIllegalArgumentException {
this.expansionFactor = expansionFactor;
setInitialCapacity(initialCapacity);
internalArray = new double[initialCapacity];
@@ -236,10 +237,10 @@ public class ResizableDoubleArray implem
* @param expansionFactor the array will be expanded based on this
* parameter
* @param contractionCriteria The contraction Criteria.
- * @throws IllegalArgumentException if parameters are not valid
+ * @throws MathIllegalArgumentException if parameters are not valid
*/
public ResizableDoubleArray(int initialCapacity, float expansionFactor,
- float contractionCriteria) {
+ float contractionCriteria) throws MathIllegalArgumentException {
this.expansionFactor = expansionFactor;
setContractionCriteria(contractionCriteria);
setInitialCapacity(initialCapacity);
@@ -265,10 +266,10 @@ public class ResizableDoubleArray implem
* parameter
* @param contractionCriteria the contraction Criteria
* @param expansionMode the expansion mode
- * @throws IllegalArgumentException if parameters are not valid
+ * @throws MathIllegalArgumentException if parameters are not valid
*/
public ResizableDoubleArray(int initialCapacity, float expansionFactor,
- float contractionCriteria, int expansionMode) {
+ float contractionCriteria, int expansionMode) throws MathIllegalArgumentException {
this.expansionFactor = expansionFactor;
setContractionCriteria(contractionCriteria);
setInitialCapacity(initialCapacity);
@@ -365,10 +366,10 @@ public class ResizableDoubleArray implem
*
* @param value new value to substitute for the most recently added value
* @return value that has been replaced in the array
- * @throws IllegalStateException if the array is empty
+ * @throws MathIllegalStateException if the array is empty
* @since 2.0
*/
- public synchronized double substituteMostRecentElement(double value) {
+ public synchronized double substituteMostRecentElement(double value) throws MathIllegalStateException {
if (numElements < 1) {
throw new MathIllegalStateException(
LocalizedFormats.CANNOT_SUBSTITUTE_ELEMENT_FROM_EMPTY_ARRAY);
@@ -389,10 +390,10 @@ public class ResizableDoubleArray implem
*
* @param expansion factor to be checked
* @param contraction criteria to be checked
- * @throws IllegalArgumentException if the contractionCriteria is less than
+ * @throws MathIllegalArgumentException if the contractionCriteria is less than
* the expansionCriteria.
*/
- protected void checkContractExpand(float contraction, float expansion) {
+ protected void checkContractExpand(float contraction, float expansion) throws MathIllegalArgumentException {
if (contraction < expansion) {
throw new MathIllegalArgumentException(
@@ -447,10 +448,10 @@ public class ResizableDoubleArray implem
* if i exceeds numElements.
*
* @param i the number of elements to discard from the front of the array
- * @throws IllegalArgumentException if i is greater than numElements.
+ * @throws MathIllegalArgumentException if i is greater than numElements.
* @since 2.0
*/
- public synchronized void discardFrontElements(int i) {
+ public synchronized void discardFrontElements(int i) throws MathIllegalArgumentException {
discardExtremeElements(i,true);
@@ -464,10 +465,10 @@ public class ResizableDoubleArray implem
* if i exceeds numElements.
*
* @param i the number of elements to discard from the end of the array
- * @throws IllegalArgumentException if i is greater than numElements.
+ * @throws MathIllegalArgumentException if i is greater than numElements.
* @since 2.0
*/
- public synchronized void discardMostRecentElements(int i) {
+ public synchronized void discardMostRecentElements(int i) throws MathIllegalArgumentException {
discardExtremeElements(i,false);
@@ -489,10 +490,10 @@ public class ResizableDoubleArray implem
* @param front true if elements are to be discarded from the front
* of the array, false if elements are to be discarded from the end
* of the array
- * @throws IllegalArgumentException if i is greater than numElements.
+ * @throws MathIllegalArgumentException if i is greater than numElements.
* @since 2.0
*/
- private synchronized void discardExtremeElements(int i,boolean front) {
+ private synchronized void discardExtremeElements(int i,boolean front) throws MathIllegalArgumentException {
if (i > numElements) {
throw new MathIllegalArgumentException(
LocalizedFormats.TOO_MANY_ELEMENTS_TO_DISCARD_FROM_ARRAY,
@@ -671,8 +672,10 @@ public class ResizableDoubleArray implem
* Sets the contraction criteria for this ExpandContractDoubleArray.
*
* @param contractionCriteria contraction criteria
+ * @throws MathIllegalArgumentException if the contractionCriteria is less than
+ * the expansionCriteria.
*/
- public void setContractionCriteria(float contractionCriteria) {
+ public void setContractionCriteria(float contractionCriteria) throws MathIllegalArgumentException {
checkContractExpand(contractionCriteria, getExpansionFactor());
synchronized(this) {
this.contractionCriteria = contractionCriteria;
@@ -713,10 +716,10 @@ public class ResizableDoubleArray implem
* <li><code>contractionFactor >= expansionFactor</code></li>
* </ul>
* @param expansionFactor the new expansion factor value.
- * @throws IllegalArgumentException if expansionFactor is <= 1 or greater
+ * @throws MathIllegalArgumentException if expansionFactor is <= 1 or greater
* than contractionFactor
*/
- public void setExpansionFactor(float expansionFactor) {
+ public void setExpansionFactor(float expansionFactor) throws MathIllegalArgumentException {
checkContractExpand(getContractionCriteria(), expansionFactor);
// The check above verifies that the expansion factor is > 1.0;
synchronized(this) {
@@ -729,9 +732,9 @@ public class ResizableDoubleArray implem
* ADDITIVE_MODE, MULTIPLICATIVE_MODE.
*
* @param expansionMode The expansionMode to set.
- * @throws IllegalArgumentException if the specified mode value is not valid
+ * @throws MathIllegalArgumentException if the specified mode value is not valid
*/
- public void setExpansionMode(int expansionMode) {
+ public void setExpansionMode(int expansionMode) throws MathIllegalArgumentException {
if (expansionMode != MULTIPLICATIVE_MODE &&
expansionMode != ADDITIVE_MODE) {
throw new MathIllegalArgumentException(
@@ -748,10 +751,10 @@ public class ResizableDoubleArray implem
* Sets the initial capacity. Should only be invoked by constructors.
*
* @param initialCapacity of the array
- * @throws IllegalArgumentException if <code>initialCapacity</code> is not
+ * @throws MathIllegalArgumentException if <code>initialCapacity</code> is not
* positive.
*/
- protected void setInitialCapacity(int initialCapacity) {
+ protected void setInitialCapacity(int initialCapacity) throws MathIllegalArgumentException {
if (initialCapacity > 0) {
synchronized(this) {
this.initialCapacity = initialCapacity;
@@ -769,9 +772,9 @@ public class ResizableDoubleArray implem
* array. This function will also expand the internal array as needed.
*
* @param i a new number of elements
- * @throws IllegalArgumentException if <code>i</code> is negative.
+ * @throws MathIllegalArgumentException if <code>i</code> is negative.
*/
- public synchronized void setNumElements(int i) {
+ public synchronized void setNumElements(int i) throws MathIllegalArgumentException {
// If index is negative thrown an error
if (i < 0) {
@@ -862,9 +865,14 @@ public class ResizableDoubleArray implem
* @since 2.0
*/
public synchronized ResizableDoubleArray copy() {
- ResizableDoubleArray result = new ResizableDoubleArray();
- copy(this, result);
- return result;
+ try {
+ ResizableDoubleArray result = new ResizableDoubleArray();
+ copy(this, result);
+ return result;
+ } catch (NullArgumentException e) {
+ // this should never happen
+ throw new MathInternalError(e);
+ }
}
/**