[cp-patches] [generics] (still) more BigDecimal methods

[Anthony Balkissoon]

I tested the rounding methods and made a fix to the round() method.
Satisfied with this I implemented several constructors that required
rounding facilities and the abs(MathContext) method that also required
rounding.

2006-02-24  Anthony Balkissoon  <[EMAIL PROTECTED]>

        * java/math/BigDecimal.java:
        (BigDecimal(long, MathContext)): New constructor.
        (BigDecimal(BigInteger, MathContext)): Likewise.
        (BigDecimal(String, MathContext)): Likewise.
        (BigDecimal(double, MathContext)): Likewise.
        (round): Fixed a typo where the precision field was used instead of a
        call to the precision method, and also store the new precision in the
        returned BigDecimal.
        (abs(MathContext)): New method.

--Tony

Index: java/math/BigDecimal.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/math/BigDecimal.java,v
retrieving revision 1.17.2.10
diff -u -r1.17.2.10 BigDecimal.java
--- java/math/BigDecimal.java	24 Feb 2006 19:44:30 -0000	1.17.2.10
+++ java/math/BigDecimal.java	24 Feb 2006 21:45:04 -0000
@@ -99,6 +99,66 @@
   }
   
   /**
+   * Constructs a BigDecimal from the long in the same way as BigDecimal(long)
+   * 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
+   * @since 1.5
+   */
+  public BigDecimal (long 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 BigDecimal whose value is given by num rounded according to 
+   * mc.  Since num is already a BigInteger, the rounding refers only to the 
+   * precision setting in mc, if mc.getPrecision() returns an int lower than
+   * 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
+   */
+  public BigDecimal (BigInteger num, MathContext mc)
+  {
+    this (num, 0);
+    if (mc.getPrecision() != 0)
+      {
+        BigDecimal result = this.round(mc);
+        this.intVal = result.intVal;
+        this.scale = result.scale;
+        this.precision = result.precision;
+      }
+  }
+  
+  /**
+   * Constructs a BigDecimal from the String val according to the same
+   * rules as the BigDecimal(String) constructor and then rounds 
+   * according to the MathContext mc.
+   * @param val the String from which we construct the initial BigDecimal
+   * @param mc the MathContext that specifies the rounding
+   * @since 1.5
+   */
+  public BigDecimal (String 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 BigDecimal whose unscaled value is num and whose
    * scale is zero.
    * @param num the value of the new BigDecimal
@@ -120,6 +180,25 @@
     this.scale = scale;
   }
 
+  /**
+   * 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
+   * @since 1.5
+   */
+  public BigDecimal (double num, MathContext mc)
+  {
+    this (num);
+    if (mc.getPrecision() != 0)
+      {
+        BigDecimal result = this.round(mc);
+        this.intVal = result.intVal;
+        this.scale = result.scale;
+        this.precision = result.precision;
+      }
+  }
+  
   public BigDecimal (double num) throws NumberFormatException 
   {
     if (Double.isInfinite (num) || Double.isNaN (num))
@@ -703,7 +782,7 @@
   public BigDecimal round(MathContext mc)
   {
     int mcPrecision = mc.getPrecision();
-    int numToChop = precision - mcPrecision;
+    int numToChop = precision() - mcPrecision;
     // If mc specifies not to chop any digits or if we've already chopped 
     // enough digits (say by using a MathContext in the constructor for this
     // BigDecimal) then just return this.
@@ -716,6 +795,7 @@
       new BigDecimal(BigInteger.valueOf((long)Math.pow(10, numToChop)));
     BigDecimal rounded = divide(div, scale, mc.getRoundingMode().ordinal());
     rounded.scale -= numToChop;
+    rounded.precision = mcPrecision;
     return rounded;
   }
   
@@ -1161,5 +1241,16 @@
     return result;
   }
   
-
+  /**
+   * Returns a BigDecimal whose value is the absolute value of this BigDecimal
+   * with rounding according to the given MathContext.
+   * @param mc the MathContext
+   * @return the new BigDecimal
+   */
+  public BigDecimal abs(MathContext mc)
+  {
+    BigDecimal result = abs();
+    result = result.round(mc);
+    return result;
+  }
 }