Some more missing stuff from the BigDecimal class. This spans 2 commits because the first time I forgot the ChangeLog entry.
2006-02-27 Anthony Balkissoon <[EMAIL PROTECTED]> * java/math/BigDecimal.java: Added @throws clause to constructors. (mathContext): Removed this unneeded field. (BigDecimal(int, MathContext)): New constructor. (BigDecimal(BigInteger, int, MathContext)): Likewise. (multiply(BigDecimal, MathContext)): New method. (negate(MathContext)): Likewise. (plus(MathContext)): Likewise. (numDigitsInLong): Fixed to properly handle negatives. --Tony
Index: java/math/BigDecimal.java =================================================================== RCS file: /cvsroot/classpath/classpath/java/math/BigDecimal.java,v retrieving revision 1.17.2.11 diff -u -r1.17.2.11 BigDecimal.java --- java/math/BigDecimal.java 24 Feb 2006 21:48:07 -0000 1.17.2.11 +++ java/math/BigDecimal.java 27 Feb 2006 19:42:03 -0000 @@ -41,7 +41,6 @@ { private BigInteger intVal; private int scale; - private MathContext mathContext; private int precision = 0; private static final long serialVersionUID = 6108874887143696463L; @@ -88,6 +87,27 @@ } /** + * Constructs a BigDecimal using the BigDecimal(int) constructor and then + * rounds according to the MathContext. + * @param val the value for the initial (unrounded) BigDecimal + * @param mc the MathContext specifying the rounding + * @throws ArithmeticException if the result is inexact but the rounding type + * is RoundingMode.UNNECESSARY + * @since 1.5 + */ + public BigDecimal (int val, MathContext mc) + { + this (val); + if (mc.getPrecision() != 0) + { + BigDecimal result = this.round(mc); + this.intVal = result.intVal; + this.scale = result.scale; + this.precision = result.precision; + } + } + + /** * Constructs a new BigDecimal whose unscaled value is val and whose * scale is zero. * @param val the value of the new BigDecimal @@ -103,6 +123,8 @@ * and then rounds according to the MathContext. * @param val the long from which we create the initial BigDecimal * @param mc the MathContext that specifies the rounding behaviour + * @throws ArithmeticException if the result is inexact but the rounding type + * is RoundingMode.UNNECESSARY * @since 1.5 */ public BigDecimal (long val, MathContext mc) @@ -124,7 +146,9 @@ * the number of digits in num, then rounding is necessary. * @param num the unscaledValue, before rounding * @param mc the MathContext that specifies the precision - * @since 1.5 + * @throws ArithmeticException if the result is inexact but the rounding type + * is RoundingMode.UNNECESSARY + * * @since 1.5 */ public BigDecimal (BigInteger num, MathContext mc) { @@ -144,6 +168,8 @@ * according to the MathContext mc. * @param val the String from which we construct the initial BigDecimal * @param mc the MathContext that specifies the rounding + * @throws ArithmeticException if the result is inexact but the rounding type + * is RoundingMode.UNNECESSARY * @since 1.5 */ public BigDecimal (String val, MathContext mc) @@ -179,12 +205,36 @@ this.intVal = num; this.scale = scale; } + + /** + * Constructs a BigDecimal using the BigDecimal(BigInteger, int) + * constructor and then rounds according to the MathContext. + * @param num the unscaled value of the unrounded BigDecimal + * @param scale the scale of the unrounded BigDecimal + * @param mc the MathContext specifying the rounding + * @throws ArithmeticException if the result is inexact but the rounding type + * is RoundingMode.UNNECESSARY + * @since 1.5 + */ + public BigDecimal (BigInteger num, int scale, MathContext mc) + { + this (num, scale); + if (mc.getPrecision() != 0) + { + BigDecimal result = this.round(mc); + this.intVal = result.intVal; + this.scale = result.scale; + this.precision = result.precision; + } + } /** * Constructs a BigDecimal in the same way as BigDecimal(double) and then * rounds according to the MathContext. * @param num the double from which the initial BigDecimal is created * @param mc the MathContext that specifies the rounding behaviour + * @throws ArithmeticException if the result is inexact but the rounding type + * is RoundingMode.UNNECESSARY * @since 1.5 */ public BigDecimal (double num, MathContext mc) @@ -569,6 +619,21 @@ { return new BigDecimal (intVal.multiply (val.intVal), scale + val.scale); } + + /** + * Returns a BigDecimal whose value is (this x val) before it is rounded + * according to the MathContext mc. + * @param val the multiplicand + * @param mc the MathContext for rounding + * @return a new BigDecimal with value approximately (this x val) + * @throws ArithmeticException if the value is inexact but the rounding mode + * is RoundingMode.UNNECESSARY + * @since 1.5 + */ + public BigDecimal multiply (BigDecimal val, MathContext mc) + { + return multiply(val).round(mc); + } public BigDecimal divide (BigDecimal val, int roundingMode) throws ArithmeticException, IllegalArgumentException @@ -763,6 +828,23 @@ } /** + * Returns a BigDecimal whose value is found first by negating this via + * the negate() method, then by rounding according to the MathContext mc. + * @param mc the MathContext for rounding + * @return a BigDecimal whose value is approximately (-this) + * @throws ArithmeticException if the value is inexact but the rounding mode + * is RoundingMode.UNNECESSARY + * @since 1.5 + */ + public BigDecimal negate(MathContext mc) + { + BigDecimal result = negate(); + if (mc.getPrecision() != 0) + result = result.round(mc); + return result; + } + + /** * Returns this BigDecimal. This is included for symmetry with the * method negate(). * @return this @@ -774,6 +856,20 @@ } /** + * Returns a BigDecimal whose value is found by rounding <code>this</code> + * according to the MathContext. This is the same as round(MathContext). + * @param mc the MathContext for rounding + * @return a BigDecimal whose value is <code>this</code> before being rounded + * @throws ArithmeticException if the value is inexact but the rounding mode + * is RoundingMode.UNNECESSARY + * @since 1.5 + */ + public BigDecimal plus(MathContext mc) + { + return round(mc); + } + + /** * Returns a BigDecimal which is this BigDecimal rounded according to the * MathContext rounding settings. * @param mc the MathContext that tells us how to round @@ -817,8 +913,9 @@ * @param l the long value * @return the number of digits in l */ - private static int numDigitsInLong(long l) + private static int numDigitsInLong(long l1) { + long l = l1 >= 0 ? l1 : -l1; // We divide up the range in a binary fashion, this first if // takes care of numbers with 1 to 9 digits. if (l < 1000000000L)