harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r436649 [1/2] - in /incubator/harmony/enhanced/classlib/trunk/modules/math/src: main/java/java/math/ test/java/org/apache/harmony/tests/java/math/
Date Fri, 25 Aug 2006 04:47:34 GMT
Author: mloenko
Date: Thu Aug 24 21:47:33 2006
New Revision: 436649

URL: http://svn.apache.org/viewvc?rev=436649&view=rev
Log:
applied patches for HARMONY-1208
Bug fixing and cosmetics for Harmony 935

Modified:
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigDecimal.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigInteger.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BitLevel.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Conversion.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Division.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Elementary.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Logical.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/MathContext.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Multiplication.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Primality.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/RoundingMode.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalArithmeticTest.java
    incubator/harmony/enhanced/classlib/trunk/modules/math/src/test/java/org/apache/harmony/tests/java/math/BigDecimalConstructorsTest.java

Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigDecimal.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigDecimal.java?rev=436649&r1=436648&r2=436649&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigDecimal.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigDecimal.java Thu Aug 24 21:47:33 2006
@@ -22,26 +22,22 @@
 import java.io.StreamCorruptedException;
 
 /**
- * @author Daniel Fridlender
- * @author Matthias Gallé
- * @author Mariano Heredia
- * @author Miguel Vasquez
+ * @author Intel Middleware Product Division
+ * @author Instituto Tecnologico de Cordoba
  * 
  * @ar.org.fitc.spec_ref 
  */
-public class BigDecimal extends Number implements Comparable<BigDecimal>,
-        Serializable {
-
+public class BigDecimal extends Number implements Comparable<BigDecimal>, Serializable {
     /* Static Fields */
 
     /** @ar.org.fitc.spec_ref */
-    public static final BigDecimal ZERO = new BigDecimal(BigInteger.ZERO, 0);
+    public static final BigDecimal ZERO = new BigDecimal(0, 0);
 
     /** @ar.org.fitc.spec_ref */
-    public static final BigDecimal ONE = new BigDecimal(BigInteger.ONE, 0);
+    public static final BigDecimal ONE = new BigDecimal(1, 0);
 
     /** @ar.org.fitc.spec_ref */
-    public static final BigDecimal TEN = new BigDecimal(BigInteger.TEN, 0);
+    public static final BigDecimal TEN = new BigDecimal(10, 0);
 
     /** @ar.org.fitc.spec_ref */
     public static final int ROUND_UP = 0;
@@ -82,19 +78,79 @@
      * An array with powers of five that fit in the type <code>long</code>
      * (<code>5^0,5^1,...,5^27</code>)
      */
-    private static final BigInteger FIVE_POW[] = new BigInteger[28];
+    private static final BigInteger FIVE_POW[];
 
     /**
      * An array with powers of ten that fit in the type <code>long</code>
      * (<code>10^0,10^1,...,10^18</code>)
      */
-    private static final BigInteger TEN_POW[] = new BigInteger[19];
+    private static final BigInteger TEN_POW[];
 
     /**
+     * An array with powers of ten that fit in the type <code>long</code>
+     * (<code>10^0,10^1,...,10^18</code>)
+     */
+    private static final long[] LONG_TEN_POW = new long[]
+    {   1L,
+        10L,
+        100L,
+        1000L,
+        10000L,
+        100000L,
+        1000000L,
+        10000000L,
+        100000000L,
+        1000000000L,
+        10000000000L,
+        100000000000L,
+        1000000000000L,
+        10000000000000L,
+        100000000000000L,
+        1000000000000000L,
+        10000000000000000L,
+        100000000000000000L,
+        1000000000000000000L, };
+    
+    
+    private static final long[] LONG_FIVE_POW = new long[]
+    {   1L,
+        5L,
+        25L,
+        125L,
+        625L,
+        3125L,
+        15625L,
+        78125L,
+        390625L,
+        1953125L,
+        9765625L,
+        48828125L,
+        244140625L,
+        1220703125L,
+        6103515625L,
+        30517578125L,
+        152587890625L,
+        762939453125L,
+        3814697265625L,
+        19073486328125L,
+        95367431640625L,
+        476837158203125L,
+        2384185791015625L,
+        11920928955078125L,
+        59604644775390625L,
+        298023223876953125L,
+        1490116119384765625L,
+        7450580596923828125L, };
+    
+    private static final int[] LONG_FIVE_POW_BIT_LENGTH = new int[LONG_FIVE_POW.length];
+    private static final int[] LONG_TEN_POW_BIT_LENGTH = new int[LONG_TEN_POW.length];
+    
+    private static final int BI_SCALED_BY_ZERO_LENGTH = 11;
+    /**
      * An array with the first <code>BigInteger</code> scaled by zero.
      * (<code>[0,0],[1,0],...,[10,0]</code>)
      */
-    private static final BigDecimal BI_SCALED_BY_ZERO[] = new BigDecimal[11];
+    private static final BigDecimal BI_SCALED_BY_ZERO[] = new BigDecimal[BI_SCALED_BY_ZERO_LENGTH];
 
     /**
      * An array with the zero number scaled by the first positive scales.
@@ -108,37 +164,37 @@
     static {
         // To fill all static arrays.
         int i = 0;
-        long fivePow = 1;
 
         for (; i < ZERO_SCALED_BY.length; i++) {
-            BI_SCALED_BY_ZERO[i] = new BigDecimal(BigInteger.valueOf(i), 0);
-            ZERO_SCALED_BY[i] = new BigDecimal(BigInteger.ZERO, i);
-            FIVE_POW[i] = BigInteger.valueOf(fivePow);
-            TEN_POW[i] = BigInteger.valueOf(fivePow << i);
+            BI_SCALED_BY_ZERO[i] = new BigDecimal(i, 0);
+            ZERO_SCALED_BY[i] = new BigDecimal(0, i);
             CH_ZEROS[i] = '0';
-            fivePow *= 5;
         }
-        for (; i < TEN_POW.length; i++) {
-            FIVE_POW[i] = BigInteger.valueOf(fivePow);
-            TEN_POW[i] = BigInteger.valueOf(fivePow << i);
+        
+        for (; i < CH_ZEROS.length; i++) {
             CH_ZEROS[i] = '0';
-            fivePow *= 5;
         }
-        for (; i < FIVE_POW.length; i++) {
-            FIVE_POW[i] = BigInteger.valueOf(fivePow);
-            CH_ZEROS[i] = '0';
-            fivePow *= 5;
+        for(int j=0; j<LONG_FIVE_POW_BIT_LENGTH.length; j++) {
+            LONG_FIVE_POW_BIT_LENGTH[j] = bitLength(LONG_FIVE_POW[j]);
         }
-        for (; i < CH_ZEROS.length; i++) {
-            CH_ZEROS[i] = '0';
+        for(int j=0; j<LONG_TEN_POW_BIT_LENGTH.length; j++) {
+            LONG_TEN_POW_BIT_LENGTH[j] = bitLength(LONG_TEN_POW[j]);
         }
+        
+        // Taking the references of usefull powers.
+        TEN_POW = Multiplication.bigTenPows;
+        FIVE_POW = Multiplication.bigFivePows;
     }
 
     /**
      * The arbitrary precision integer (unscaled value) in the internal
      * representation of <code>BigDecimal</code>.
      */
-    private BigInteger unscaledValue;
+    private BigInteger intVal;
+    
+    private transient int bitLength;
+    
+    private transient long smallValue;
 
     /** 
      * The 32-bit integer scale in the internal representation of <code>BigDecimal</code>. 
@@ -153,10 +209,23 @@
      * @see #precision()
      * @see #inplaceRound(MathContext)
      */
-    private int precision = 0;
+    private transient int precision = 0;
 
     /* Constructors */
 
+    private BigDecimal(long smallValue, int scale){
+        this.smallValue = smallValue;
+        this.scale = scale;
+        this.bitLength = bitLength(smallValue);
+    }
+    
+    private BigDecimal(int smallValue, int scale){
+        this.smallValue = smallValue;
+        this.scale = scale;
+        this.bitLength = bitLength(smallValue);
+    }
+    
+    
     /** @ar.org.fitc.spec_ref */
     public BigDecimal(char[] in, int offset, int len) {
         int begin = offset; // first index to be copied
@@ -178,9 +247,8 @@
             begin++;
         }
         // Acumulating all digits until a possible decimal point
-        for (; (offset <= last) && (in[offset] != '.') && (in[offset] != 'e')
-                && (in[offset] != 'E'); offset++)
-            ;
+        for (; (offset <= last) && (in[offset] != '.')
+        && (in[offset] != 'e') && (in[offset] != 'E'); offset++);
         unscaledBuffer.append(in, begin, offset - begin);
         // A decimal point was found
         if ((offset <= last) && (in[offset] == '.')) {
@@ -188,8 +256,7 @@
             // Acumulating all digits until a possible exponent
             begin = offset;
             for (; (offset <= last) && (in[offset] != 'e')
-                    && (in[offset] != 'E'); offset++)
-                ;
+            && (in[offset] != 'E'); offset++);
             scale = offset - begin;
             unscaledBuffer.append(in, begin, scale);
         } else {
@@ -209,14 +276,14 @@
             // Acumulating all reminaining digits
             scaleString = String.valueOf(in, begin, last + 1 - begin);
             // Checking if the scale is defined            
-            newScale = (long) scale - Integer.parseInt(scaleString);
-            scale = (int) newScale;
+            newScale = (long)scale - Integer.parseInt(scaleString);
+            scale = (int)newScale;
             if (newScale != scale) {
                 throw new NumberFormatException("Scale out of range.");
             }
         }
         // Parsing the unscaled value
-        unscaledValue = new BigInteger(unscaledBuffer.toString());
+        setUnscaledValue(new BigInteger(unscaledBuffer.toString()));
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -256,28 +323,41 @@
         long mantisa;
         int trailingZeros;
         // Extracting the exponent, note that the bias is 1023
-        scale = 1075 - (int) ((bits >> 52) & 0x7FFL);
+        scale = 1075 - (int)((bits >> 52) & 0x7FFL);
         // Extracting the 52 bits of the mantisa.
         mantisa = (scale == 1075) ? (bits & 0xFFFFFFFFFFFFFL) << 1
                 : (bits & 0xFFFFFFFFFFFFFL) | 0x10000000000000L;
         // To simplify all factors '2' in the mantisa 
         if (scale > 0) {
-            trailingZeros = Math
-                    .min(scale, Long.numberOfTrailingZeros(mantisa));
+            trailingZeros = Math.min(scale, Long.numberOfTrailingZeros(mantisa));
             mantisa >>>= trailingZeros;
             scale -= trailingZeros;
         }
         // Calculating the new unscaled value and the new scale
-        unscaledValue = BigInteger.valueOf(((bits >> 63) == 0) ? mantisa
-                : -mantisa);
+        if((bits >> 63) != 0) {
+            mantisa = -mantisa;
+        }
+        int mantisaBits = bitLength(mantisa);
         if (scale < 0) {
-            unscaledValue = unscaledValue.shiftLeft(-scale);
+            bitLength = mantisaBits == 0 ? 0 : mantisaBits - scale;
+            if(bitLength < 64) {
+                smallValue = mantisa << (-scale);
+            } else {
+                intVal = BigInteger.valueOf(mantisa).shiftLeft(-scale);
+            }
             scale = 0;
         } else if (scale > 0) {
             // m * 2^e =  (m * 5^(-e)) * 10^e
-            unscaledValue = (scale < FIVE_POW.length) ? unscaledValue
-                    .multiply(FIVE_POW[scale]) : unscaledValue
-                    .multiply(FIVE_POW[1].pow(scale));
+            if(scale < LONG_FIVE_POW.length
+                    && mantisaBits+LONG_FIVE_POW_BIT_LENGTH[scale] < 64) {
+                smallValue = mantisa * LONG_FIVE_POW[scale];
+                bitLength = bitLength(smallValue);
+            } else {
+                setUnscaledValue(Multiplication.multiplyByFivePow(BigInteger.valueOf(mantisa), scale));
+            }
+        } else { // scale == 0
+            smallValue = mantisa;
+            bitLength = mantisaBits;
         }
     }
 
@@ -300,8 +380,11 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal(BigInteger unscaledVal, int scale) {
-        unscaledValue = unscaledVal;
+        if (unscaledVal == null) {
+            throw new NullPointerException();
+        }
         this.scale = scale;
+        setUnscaledValue(unscaledVal);
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -312,19 +395,18 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal(int val) {
-        this((long) val);
+        this(val,0);
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal(int val, MathContext mc) {
-        this((long) val);
+        this(val,0);
         inplaceRound(mc);
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal(long val) {
-        unscaledValue = BigInteger.valueOf(val);
-        scale = 0;
+        this(val,0);
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -337,20 +419,22 @@
 
     /** @ar.org.fitc.spec_ref */
     public static BigDecimal valueOf(long unscaledVal, int scale) {
+        if (scale == 0) {
+            return valueOf(unscaledVal);
+        }
         if ((unscaledVal == 0) && (scale >= 0)
                 && (scale < ZERO_SCALED_BY.length)) {
             return ZERO_SCALED_BY[scale];
         }
-        if ((scale == 0) && (unscaledVal >= 0)
-                && (unscaledVal < BI_SCALED_BY_ZERO.length)) {
-            return BI_SCALED_BY_ZERO[(int) unscaledVal];
-        }
-        return new BigDecimal(BigInteger.valueOf(unscaledVal), scale);
+        return new BigDecimal(unscaledVal, scale);
     }
 
     /** @ar.org.fitc.spec_ref */
-    public static BigDecimal valueOf(long val) {
-        return valueOf(val, 0);
+    public static BigDecimal valueOf(long unscaledVal) {
+        if ((unscaledVal >= 0) && (unscaledVal < BI_SCALED_BY_ZERO_LENGTH)) {
+            return BI_SCALED_BY_ZERO[(int)unscaledVal];
+        }
+        return new BigDecimal(unscaledVal,0);
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -363,16 +447,16 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal add(BigDecimal augend) {
-        long diffScale = (long) this.scale - augend.scale;
+        int diffScale = this.scale - augend.scale;
         // Fast return when some operand is zero
-        if (this.signum() == 0) {
+        if (this.isZero()) {
             if (diffScale <= 0) {
                 return augend;
             }
-            if (augend.signum() == 0) {
+            if (augend.isZero()) {
                 return this;
             }
-        } else if (augend.signum() == 0) {
+        } else if (augend.isZero()) {
             if (diffScale >= 0) {
                 return this;
             }
@@ -380,27 +464,37 @@
         // Let be:  this = [u1,s1]  and  augend = [u2,s2]
         if (diffScale == 0) {
             // case s1 == s2: [u1 + u2 , s1]
-            return new BigDecimal(this.unscaledValue.add(augend.unscaledValue),
-                    this.scale);
+            if (Math.max(this.bitLength, augend.bitLength) + 1 < 64) {
+                return valueOf(this.smallValue + augend.smallValue, this.scale);
+            } else {
+                return new BigDecimal(this.getUnscaledValue().add(augend.getUnscaledValue()), this.scale);
+            }
         } else if (diffScale > 0) {
             // case s1 > s2 : [(u1 + u2) * 10 ^ (s1 - s2) , s1]
-            return new BigDecimal(this.unscaledValue.add(augend.unscaledValue
-                    .multiply(powerOf10(diffScale))), this.scale);
+            return addAndMult10(this, augend, diffScale);
         } else {// case s2 > s1 : [(u2 + u1) * 10 ^ (s2 - s1) , s2]
-            return new BigDecimal(augend.unscaledValue.add(this.unscaledValue
-                    .multiply(powerOf10(-diffScale))), augend.scale);
+            return addAndMult10(augend, this, -diffScale);
         }
     }
 
+    private static BigDecimal addAndMult10(BigDecimal thisValue,BigDecimal augend, int diffScale) {
+        if(diffScale < LONG_TEN_POW.length &&
+                Math.max(thisValue.bitLength,augend.bitLength+LONG_TEN_POW_BIT_LENGTH[diffScale])+1<64) {
+            return valueOf(thisValue.smallValue+augend.smallValue*LONG_TEN_POW[diffScale],thisValue.scale);
+        }
+        return new BigDecimal(thisValue.getUnscaledValue().add(
+                Multiplication.multiplyByTenPow(augend.getUnscaledValue(),diffScale)), thisValue.scale);
+    }
+    
     /** @ar.org.fitc.spec_ref */
     public BigDecimal add(BigDecimal augend, MathContext mc) {
         BigDecimal larger; // operand with the largest unscaled value
         BigDecimal smaller; // operand with the smallest unscaled value
         BigInteger tempBI;
-        long diffScale = (long) this.scale - augend.scale;
+        long diffScale = (long)this.scale - augend.scale;
         int largerSignum;
         // Some operand is zero or the precision is infinity  
-        if ((augend.signum() == 0) || (this.signum() == 0)
+        if ((augend.isZero()) || (this.isZero())
                 || (mc.getPrecision() == 0)) {
             return add(augend).round(mc);
         }
@@ -421,13 +515,13 @@
         // Cases where it's unnecessary to add two numbers with very different scales 
         largerSignum = larger.signum();
         if (largerSignum == smaller.signum()) {
-            tempBI = larger.unscaledValue.multiply(BigInteger.TEN).add(
-                    BigInteger.valueOf(largerSignum));
+            tempBI = Multiplication.multiplyByPositiveInt(larger.getUnscaledValue(),10)
+            .add(BigInteger.valueOf(largerSignum));
         } else {
-            tempBI = larger.unscaledValue.subtract(BigInteger
-                    .valueOf(largerSignum));
-            tempBI = tempBI.multiply(BigInteger.TEN).add(
-                    BigInteger.valueOf(largerSignum * 9));
+            tempBI = larger.getUnscaledValue().subtract(
+                    BigInteger.valueOf(largerSignum));
+            tempBI = Multiplication.multiplyByPositiveInt(tempBI,10)
+            .add(BigInteger.valueOf(largerSignum * 9));
         }
         // Rounding the improved adding 
         larger = new BigDecimal(tempBI, larger.scale + 1);
@@ -436,16 +530,16 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal subtract(BigDecimal subtrahend) {
-        long diffScale = (long) this.scale - subtrahend.scale;
+        int diffScale = this.scale - subtrahend.scale;
         // Fast return when some operand is zero
-        if (this.signum() == 0) {
+        if (this.isZero()) {
             if (diffScale <= 0) {
                 return subtrahend.negate();
             }
-            if (subtrahend.signum() == 0) {
+            if (subtrahend.isZero()) {
                 return this;
             }
-        } else if (subtrahend.signum() == 0) {
+        } else if (subtrahend.isZero()) {
             if (diffScale >= 0) {
                 return this;
             }
@@ -453,28 +547,38 @@
         // Let be: this = [u1,s1] and subtrahend = [u2,s2] so:
         if (diffScale == 0) {
             // case s1 = s2 : [u1 - u2 , s1]
-            return new BigDecimal(this.unscaledValue
-                    .subtract(subtrahend.unscaledValue), this.scale);
+            if (Math.max(this.bitLength, subtrahend.bitLength) + 1 < 64) {
+                return valueOf(this.smallValue - subtrahend.smallValue,this.scale);
+            } else {
+                return new BigDecimal(this.getUnscaledValue().subtract(subtrahend.getUnscaledValue()), this.scale);
+            }
         } else if (diffScale > 0) {
             // case s1 > s2 : [ u1 - u2 * 10 ^ (s1 - s2) , s1 ]
-            return new BigDecimal(this.unscaledValue
-                    .subtract(subtrahend.unscaledValue
-                            .multiply(powerOf10(diffScale))), this.scale);
+            if(diffScale < LONG_TEN_POW.length &&
+                    Math.max(this.bitLength,subtrahend.bitLength+LONG_TEN_POW_BIT_LENGTH[diffScale])+1<64) {
+                return valueOf(this.smallValue-subtrahend.smallValue*LONG_TEN_POW[diffScale],this.scale);
+            }
+            return new BigDecimal(this.getUnscaledValue().subtract(
+                    Multiplication.multiplyByTenPow(subtrahend.getUnscaledValue(),diffScale)), this.scale);
         } else {// case s2 > s1 : [ u1 * 10 ^ (s2 - s1) - u2 , s2 ]
-            return new BigDecimal(this.unscaledValue.multiply(
-                    powerOf10(-diffScale)).subtract(subtrahend.unscaledValue),
-                    subtrahend.scale);
+            diffScale = -diffScale;
+            if(diffScale < LONG_TEN_POW.length &&
+                    Math.max(this.bitLength+LONG_TEN_POW_BIT_LENGTH[diffScale],subtrahend.bitLength)+1<64) {
+                return valueOf(this.smallValue*LONG_TEN_POW[diffScale]-subtrahend.smallValue,subtrahend.scale);
+            }
+            return new BigDecimal(Multiplication.multiplyByTenPow(this.getUnscaledValue(),diffScale)
+            .subtract(subtrahend.getUnscaledValue()), subtrahend.scale);
         }
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal subtract(BigDecimal subtrahend, MathContext mc) {
-        long diffScale = subtrahend.scale - (long) this.scale;
+        long diffScale = subtrahend.scale - (long)this.scale;
         int thisSignum;
         BigDecimal leftOperand; // it will be only the left operand (this) 
         BigInteger tempBI;
         // Some operand is zero or the precision is infinity  
-        if ((subtrahend.signum() == 0) || (this.signum() == 0)
+        if ((subtrahend.isZero()) || (this.isZero())
                 || (mc.getPrecision() == 0)) {
             return subtract(subtrahend).round(mc);
         }
@@ -484,13 +588,12 @@
             if (mc.getPrecision() < this.aproxPrecision()) {
                 thisSignum = this.signum();
                 if (thisSignum != subtrahend.signum()) {
-                    tempBI = this.unscaledValue.multiply(BigInteger.TEN).add(
-                            BigInteger.valueOf(thisSignum));
+                    tempBI = Multiplication.multiplyByPositiveInt(this.getUnscaledValue(), 10)
+                    .add(BigInteger.valueOf(thisSignum));
                 } else {
-                    tempBI = this.unscaledValue.subtract(BigInteger
-                            .valueOf(thisSignum));
-                    tempBI = tempBI.multiply(BigInteger.TEN).add(
-                            BigInteger.valueOf(thisSignum * 9));
+                    tempBI = this.getUnscaledValue().subtract(BigInteger.valueOf(thisSignum));
+                    tempBI = Multiplication.multiplyByPositiveInt(tempBI, 10)
+                    .add(BigInteger.valueOf(thisSignum * 9));
                 }
                 // Rounding the improved substracting
                 leftOperand = new BigDecimal(tempBI, this.scale + 1);
@@ -503,15 +606,18 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal multiply(BigDecimal multiplicand) {
-        long newScale = (long) this.scale + multiplicand.scale;
+        long newScale = (long)this.scale + multiplicand.scale;
 
-        if ((this.signum() == 0) || (multiplicand.signum() == 0)) {
+        if ((this.isZero()) || (multiplicand.isZero())) {
             return zeroScaledBy(newScale);
         } else {
             /* Let be: this = [u1,s1] and multiplicand = [u2,s2] so:
              * this x multiplicand = [ s1 * s2 , s1 + s2 ] */
-            return new BigDecimal(this.unscaledValue
-                    .multiply(multiplicand.unscaledValue), toIntScale(newScale));
+            if(this.bitLength + multiplicand.bitLength < 64) {
+                return valueOf(this.smallValue*multiplicand.smallValue,toIntScale(newScale));
+            }
+            return new BigDecimal(this.getUnscaledValue().multiply(
+                    multiplicand.getUnscaledValue()), toIntScale(newScale));
         }
     }
 
@@ -529,42 +635,106 @@
     }
 
     /** @ar.org.fitc.spec_ref */
-    public BigDecimal divide(BigDecimal divisor, int scale,
-            RoundingMode roundingMode) {
+    public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) {
         // Let be: this = [u1,s1]  and  divisor = [u2,s2]
-        long diffScale = ((long) this.scale - divisor.scale) - (long) scale;
-        int sign = this.signum() * divisor.signum(); // sign of the result
-        int compRem; // 'compare to remainder'
-        BigInteger quotAndRem[] = { this.unscaledValue }; // quotient and remainder
-        BigInteger scaledDivisor = divisor.unscaledValue; // for scaling of 'u2'
-
         if (roundingMode == null) {
             throw new NullPointerException();
         }
-        if (divisor.signum() == 0) {
-            throw new ArithmeticException("BigInteger divide by zero");
+        if (divisor.isZero()) {
+            throw new ArithmeticException("Division by zero");
         }
+        
+        long diffScale = ((long)this.scale - divisor.scale) - (long)scale;
+        if(this.bitLength < 64 && divisor.bitLength < 64 ) {
+            if(diffScale == 0) {
+                return dividePrimitiveLongs(this.smallValue,
+                        divisor.smallValue,
+                        scale,
+                        roundingMode );
+            } else if(diffScale > 0) {
+                if(diffScale < LONG_TEN_POW.length &&
+                        divisor.bitLength + LONG_TEN_POW_BIT_LENGTH[(int)diffScale] < 64) {
+                    return dividePrimitiveLongs(this.smallValue,
+                            divisor.smallValue*LONG_TEN_POW[(int)diffScale],
+                            scale,
+                            roundingMode);
+                }
+            } else { // diffScale < 0
+                if(-diffScale < LONG_TEN_POW.length &&
+                        this.bitLength + LONG_TEN_POW_BIT_LENGTH[(int)-diffScale] < 64) {
+                    return dividePrimitiveLongs(this.smallValue*LONG_TEN_POW[(int)-diffScale],
+                            divisor.smallValue,
+                            scale,
+                            roundingMode);
+                }
+                
+            }
+        }
+        BigInteger scaledDividend = this.getUnscaledValue();
+        BigInteger scaledDivisor = divisor.getUnscaledValue(); // for scaling of 'u2'
+        
         if (diffScale > 0) {
             // Multiply 'u2'  by:  10^((s1 - s2) - scale)
-            scaledDivisor = scaledDivisor.multiply(powerOf10(diffScale));
+            scaledDivisor = Multiplication.multiplyByTenPow(scaledDivisor, (int)diffScale);
         } else if (diffScale < 0) {
             // Multiply 'u1'  by:  10^(scale - (s1 - s2))
-            quotAndRem[0] = quotAndRem[0].multiply(powerOf10(-diffScale));
+            scaledDividend  = Multiplication.multiplyByTenPow(scaledDividend, (int)-diffScale);
+        }
+        return divideBigIntegers(scaledDividend, scaledDivisor, scale, roundingMode);
         }
-        quotAndRem = quotAndRem[0].divideAndRemainder(scaledDivisor);
+    
+    private static BigDecimal divideBigIntegers(BigInteger scaledDividend, BigInteger scaledDivisor, int scale, RoundingMode roundingMode) {
+        
+        BigInteger[] quotAndRem = scaledDividend.divideAndRemainder(scaledDivisor);  // quotient and remainder
         // If after division there is a remainder...
-        if (quotAndRem[1].signum() != 0) {
+        BigInteger quotient = quotAndRem[0];
+        BigInteger remainder = quotAndRem[1];
+        if (remainder.signum() == 0) {
+            return new BigDecimal(quotient, scale);
+        }
+        int sign = scaledDividend.signum() * scaledDivisor.signum();
+        int compRem;                                      // 'compare to remainder'
+        if(scaledDivisor.bitLength() < 63) { // 63 in order to avoid out of long after <<1
+            long rem = remainder.longValue();
+            long divisor = scaledDivisor.longValue();
+            compRem = longCompareTo(Math.abs(rem) << 1,Math.abs(divisor));
+            // To look if there is a carry
+            compRem = roundingBehavior(quotient.testBit(0) ? 1 : 0,
+                    sign * (5 + compRem), roundingMode);
+            
+        } else {
             // Checking if:  remainder * 2 >= scaledDivisor 
-            compRem = quotAndRem[1].abs().shiftLeft(1).compareTo(
-                    scaledDivisor.abs());
-            compRem = roundingBehavior(quotAndRem[0].testBit(0) ? 1 : 0, sign
-                    * (5 + compRem), roundingMode);
+            compRem = remainder.abs().shiftLeft(1).compareTo(scaledDivisor.abs());
+            compRem = roundingBehavior(quotient.testBit(0) ? 1 : 0,
+                    sign * (5 + compRem), roundingMode);
+        }
             if (compRem != 0) {
-                quotAndRem[0] = quotAndRem[0].add(BigInteger.valueOf(compRem));
+            if(quotient.bitLength() < 63) {
+                return valueOf(quotient.longValue() + compRem,scale);
+            } else {
+                quotient = quotient.add(BigInteger.valueOf(compRem));
+                return new BigDecimal(quotient, scale);
             }
         }
         // Constructing the result with the appropriate unscaled value
-        return new BigDecimal(quotAndRem[0], scale);
+        return new BigDecimal(quotient, scale);
+    }
+    
+    private static BigDecimal dividePrimitiveLongs(long scaledDividend, long scaledDivisor, int scale, RoundingMode roundingMode) {
+        long quotient = scaledDividend / scaledDivisor;
+        long remainder = scaledDividend % scaledDivisor;
+        int sign = Long.signum( scaledDividend ) * Long.signum( scaledDivisor );
+        if (remainder != 0) {
+            // Checking if:  remainder * 2 >= scaledDivisor
+            int compRem;                                      // 'compare to remainder'
+            compRem = longCompareTo(Math.abs(remainder) << 1,Math.abs(scaledDivisor));
+            // To look if there is a carry
+            quotient += roundingBehavior(((int)quotient) & 1,
+                    sign * (5 + compRem),
+                    roundingMode);
+        }
+        // Constructing the result with the appropriate unscaled value
+        return valueOf(quotient, scale);
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -579,19 +749,19 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal divide(BigDecimal divisor) {
-        BigInteger p = this.unscaledValue;
-        BigInteger q = divisor.unscaledValue;
+        BigInteger p = this.getUnscaledValue();
+        BigInteger q = divisor.getUnscaledValue();
         BigInteger gcd; // greatest common divisor between 'p' and 'q'
         BigInteger quotAndRem[];
-        long diffScale = (long) scale - divisor.scale;
+        long diffScale = (long)scale - divisor.scale;
         int newScale; // the new scale for final quotient
         int k; // number of factors "2" in 'q'
         int l = 0; // number of factors "5" in 'q'
         int i = 1;
         int lastPow = FIVE_POW.length - 1;
 
-        if (divisor.signum() == 0) {
-            throw new ArithmeticException("BigInteger divide by zero");
+        if (divisor.isZero()) {
+            throw new ArithmeticException("Division by zero");
         }
         if (p.signum() == 0) {
             return zeroScaledBy(diffScale);
@@ -632,8 +802,9 @@
         newScale = toIntScale(diffScale + Math.max(k, l));
         // k >= 0  and  l >= 0  implies that  k - l  is in the 32-bit range
         i = k - l;
-        p = (i >= FIVE_POW.length) ? p.multiply(FIVE_POW[1].pow(i))
-                : (i > 0) ? p.multiply(FIVE_POW[i]) : p.shiftLeft(i);
+        
+        p = (i > 0) ? Multiplication.multiplyByFivePow(p, i)
+        : p.shiftLeft(-i);
         return new BigDecimal(p, newScale);
     }
 
@@ -641,35 +812,34 @@
     public BigDecimal divide(BigDecimal divisor, MathContext mc) {
         /* Calculating how many zeros must be append to 'dividend'
          * to obtain a  quotient with at least 'mc.precision()' digits */
-        long traillingZeros = (long) mc.getPrecision() + 2L
-                + (long) divisor.aproxPrecision() - (long) aproxPrecision();
-        long diffScale = (long) scale - divisor.scale;
+        long traillingZeros = (long)mc.getPrecision() + 2L
+                + (long)divisor.aproxPrecision() - (long)aproxPrecision();
+        long diffScale = (long)scale - divisor.scale;
         long newScale = diffScale; // scale of the final quotient
         int compRem; // to compare the remainder
         int i = 1; // index   
         int lastPow = TEN_POW.length - 1; // last power of ten
         BigInteger integerQuot; // for temporal results
-        BigInteger quotAndRem[] = { unscaledValue };
+        BigInteger quotAndRem[] = {getUnscaledValue()};
         // In special cases it reduces the problem to call the dual method
-        if ((mc.getPrecision() == 0) || (this.signum() == 0)
-                || (divisor.signum() == 0)) {
+        if ((mc.getPrecision() == 0) || (this.isZero())
+        || (divisor.isZero())) {
             return this.divide(divisor);
         }
         if (traillingZeros > 0) {
             // To append trailing zeros at end of dividend
-            quotAndRem[0] = unscaledValue.multiply(powerOf10(traillingZeros));
+            quotAndRem[0] = getUnscaledValue().multiply( Multiplication.powerOf10(traillingZeros) );
             newScale += traillingZeros;
         }
-        quotAndRem = quotAndRem[0].divideAndRemainder(divisor.unscaledValue);
+        quotAndRem = quotAndRem[0].divideAndRemainder( divisor.getUnscaledValue() );
         integerQuot = quotAndRem[0];
         // Calculating the exact quotient with at least 'mc.precision()' digits
         if (quotAndRem[1].signum() != 0) {
             // Checking if:   2 * remainder >= divisor ?
-            compRem = quotAndRem[1].shiftLeft(1).compareTo(
-                    divisor.unscaledValue);
+            compRem = quotAndRem[1].shiftLeft(1).compareTo( divisor.getUnscaledValue() );
             // quot := quot * 10 + r;     with 'r' in {-6,-5,-4, 0,+4,+5,+6}
-            integerQuot = integerQuot.multiply(BigInteger.TEN).add(
-                    BigInteger.valueOf(quotAndRem[0].signum() * (5 + compRem)));
+            integerQuot = integerQuot.multiply(BigInteger.TEN)
+            .add(BigInteger.valueOf(quotAndRem[0].signum() * (5 + compRem)));
             newScale++;
         } else {
             // To strip trailing zeros until the preferred scale is reached
@@ -698,31 +868,29 @@
     public BigDecimal divideToIntegralValue(BigDecimal divisor) {
         BigInteger integralValue; // the integer of result
         BigInteger powerOfTen; // some power of ten
-        BigInteger quotAndRem[] = { unscaledValue };
-        long newScale = (long) this.scale - divisor.scale;
+        BigInteger quotAndRem[] = {getUnscaledValue()};
+        long newScale = (long)this.scale - divisor.scale;
         long tempScale = 0;
         int i = 1;
         int lastPow = TEN_POW.length - 1;
 
-        if (divisor.signum() == 0) {
-            throw new ArithmeticException("BigInteger divide by zero");
+        if (divisor.isZero()) {
+            throw new ArithmeticException("Division by zero");
         }
         if ((divisor.aproxPrecision() + newScale > this.aproxPrecision() + 1L)
-                || (this.signum() == 0)) {
+        || (this.isZero())) {
             /* If the divisor's integer part is greater than this's integer part,
              * the result must be zero with the apropriate scale */
             integralValue = BigInteger.ZERO;
         } else if (newScale == 0) {
-            integralValue = unscaledValue.divide(divisor.unscaledValue);
+            integralValue = getUnscaledValue().divide( divisor.getUnscaledValue() );
         } else if (newScale > 0) {
-            powerOfTen = powerOf10(newScale);
-            integralValue = unscaledValue.divide(divisor.unscaledValue
-                    .multiply(powerOfTen));
+            powerOfTen = Multiplication.powerOf10(newScale);
+            integralValue = getUnscaledValue().divide( divisor.getUnscaledValue().multiply(powerOfTen) );
             integralValue = integralValue.multiply(powerOfTen);
         } else {// (newScale < 0)
-            powerOfTen = powerOf10(-newScale);
-            integralValue = unscaledValue.multiply(powerOfTen).divide(
-                    divisor.unscaledValue);
+            powerOfTen = Multiplication.powerOf10(-newScale);
+            integralValue = getUnscaledValue().multiply(powerOfTen).divide( divisor.getUnscaledValue() );
             // To strip trailing zeros aproximating to the preferred scale
             while (!integralValue.testBit(0)) {
                 quotAndRem = integralValue.divideAndRemainder(TEN_POW[i]);
@@ -742,7 +910,8 @@
             }
             newScale = tempScale;
         }
-        return ((integralValue.signum() == 0) ? zeroScaledBy(newScale)
+        return ((integralValue.signum() == 0)
+        ? zeroScaledBy(newScale)
                 : new BigDecimal(integralValue, toIntScale(newScale)));
     }
 
@@ -751,13 +920,12 @@
         int mcPrecision = mc.getPrecision();
         int diffPrecision = this.precision() - divisor.precision();
         int lastPow = TEN_POW.length - 1;
-        long diffScale = (long) this.scale - divisor.scale;
+        long diffScale = (long)this.scale - divisor.scale;
         long newScale = diffScale;
         long quotPrecision = diffPrecision - diffScale + 1;
         BigInteger quotAndRem[] = new BigInteger[2];
         // In special cases it call the dual method
-        if ((mcPrecision == 0) || (this.signum() == 0)
-                || (divisor.signum() == 0)) {
+        if ((mcPrecision == 0) || (this.isZero()) || (divisor.isZero())) {
             return this.divideToIntegralValue(divisor);
         }
         // Let be:   this = [u1,s1]   and   divisor = [u2,s2]
@@ -765,36 +933,34 @@
             quotAndRem[0] = BigInteger.ZERO;
         } else if (diffScale == 0) {
             // CASE s1 == s2:  to calculate   u1 / u2 
-            quotAndRem[0] = this.unscaledValue.divide(divisor.unscaledValue);
+            quotAndRem[0] = this.getUnscaledValue().divide( divisor.getUnscaledValue() );
         } else if (diffScale > 0) {
             // CASE s1 >= s2:  to calculate   u1 / (u2 * 10^(s1-s2)  
-            quotAndRem[0] = this.unscaledValue.divide(divisor.unscaledValue
-                    .multiply(powerOf10(diffScale)));
+            quotAndRem[0] = this.getUnscaledValue().divide(
+                    divisor.getUnscaledValue().multiply(Multiplication.powerOf10(diffScale)) );
             // To chose  10^newScale  to get a quotient with at least 'mc.precision()' digits
-            newScale = Math.min(diffScale, Math.max((long) mcPrecision
-                    - quotPrecision + 1, 0));
+            newScale = Math.min(diffScale, Math.max((long)mcPrecision - quotPrecision + 1, 0));
             // To calculate: (u1 / (u2 * 10^(s1-s2)) * 10^newScale
-            quotAndRem[0] = quotAndRem[0].multiply(powerOf10(newScale));
+            quotAndRem[0] = quotAndRem[0].multiply(Multiplication.powerOf10(newScale));
         } else {// CASE s2 > s1:   
             /* To calculate the minimus power of ten, such that the quotient 
              *   (u1 * 10^exp) / u2   has at least 'mc.precision()' digits. */
-            long exp = Math.min(-diffScale, Math.max((long) mcPrecision
-                    - diffPrecision, 0));
+            long exp = Math.min(-diffScale, Math.max((long)mcPrecision - diffPrecision, 0));
             long compRemDiv;
             // Let be:   (u1 * 10^exp) / u2 = [q,r]  
-            quotAndRem = this.unscaledValue.multiply(powerOf10(exp))
-                    .divideAndRemainder(divisor.unscaledValue);
+            quotAndRem = this.getUnscaledValue().multiply(Multiplication.powerOf10(exp)).
+                    divideAndRemainder(divisor.getUnscaledValue());
             newScale += exp; // To fix the scale
             exp = -newScale; // The remaining power of ten
             // If after division there is a remainder...
             if ((quotAndRem[1].signum() != 0) && (exp > 0)) {
                 // Log10(r) + ((s2 - s1) - exp) > mc.precision ?
-                compRemDiv = (new BigDecimal(quotAndRem[1])).precision() + exp
-                        - (long) divisor.precision();
+                compRemDiv = (new BigDecimal(quotAndRem[1])).precision()
+                + exp - (long)divisor.precision();
                 if (compRemDiv == 0) {
                     // To calculate:  (r * 10^exp2) / u2
-                    quotAndRem[1] = quotAndRem[1].multiply(powerOf10(exp))
-                            .divide(divisor.unscaledValue);
+                    quotAndRem[1] = quotAndRem[1].multiply(Multiplication.powerOf10(exp)).
+                            divide(divisor.getUnscaledValue());
                     compRemDiv = Math.abs(quotAndRem[1].signum());
                 }
                 if (compRemDiv > 0) {
@@ -814,8 +980,9 @@
         // To strip trailing zeros until the specified precision is reached
         while (!strippedBI.testBit(0)) {
             quotAndRem = strippedBI.divideAndRemainder(TEN_POW[i]);
-            if ((quotAndRem[1].signum() == 0)
-                    && ((resultPrecision - i >= mcPrecision) || (newScale - i >= diffScale))) {
+            if ((quotAndRem[1].signum() == 0) &&
+                    ((resultPrecision - i >= mcPrecision)
+                    || (newScale - i >= diffScale)) ) {
                 resultPrecision -= i;
                 newScale -= i;
                 if (i < lastPow) {
@@ -833,8 +1000,8 @@
         if (resultPrecision > mcPrecision) {
             throw new ArithmeticException("Division impossible");
         } else {
-            integralValue.unscaledValue = strippedBI;
             integralValue.scale = toIntScale(newScale);
+            integralValue.setUnscaledValue(strippedBI);
             return integralValue;
         }
     }
@@ -854,7 +1021,7 @@
         BigDecimal quotAndRem[] = new BigDecimal[2];
 
         quotAndRem[0] = this.divideToIntegralValue(divisor);
-        quotAndRem[1] = this.subtract(quotAndRem[0].multiply(divisor));
+        quotAndRem[1] = this.subtract( quotAndRem[0].multiply(divisor) );
         return quotAndRem;
     }
 
@@ -863,7 +1030,7 @@
         BigDecimal quotAndRem[] = new BigDecimal[2];
 
         quotAndRem[0] = this.divideToIntegralValue(divisor, mc);
-        quotAndRem[1] = this.subtract(quotAndRem[0].multiply(divisor));
+        quotAndRem[1] = this.subtract( quotAndRem[0].multiply(divisor) );
         return quotAndRem;
     }
 
@@ -875,10 +1042,11 @@
         if ((n < 0) || (n > 999999999)) {
             throw new ArithmeticException("Invalid operation");
         }
-        long newScale = scale * (long) n;
+        long newScale = scale * (long)n;
         // Let be: this = [u,s]   so:  this^n = [u^n, s*n]
-        return ((signum() == 0) ? zeroScaledBy(newScale) : new BigDecimal(
-                unscaledValue.pow(n), toIntScale(newScale)));
+        return ((isZero())
+        ? zeroScaledBy(newScale)
+        : new BigDecimal(getUnscaledValue().pow(n), toIntScale(newScale)));
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -886,13 +1054,13 @@
         // The ANSI standard X3.274-1996 algorithm
         int m = Math.abs(n);
         int mcPrecision = mc.getPrecision();
-        int elength = (int) Math.log10(m) + 1; // decimal digits in 'n' 
+        int elength = (int)Math.log10(m) + 1;   // decimal digits in 'n'
         int oneBitMask; // mask of bits
         BigDecimal accum; // the single accumulator
         MathContext newPrecision = mc; // MathContext by default
 
         // In particular cases, it reduces the problem to call the other 'pow()'
-        if ((n == 0) || ((signum() == 0) && (n > 0))) {
+        if ((n == 0) || ((isZero()) && (n > 0))) {
             return pow(n);
         }
         if ((m > 999999999) || ((mcPrecision == 0) && (n < 0))
@@ -900,8 +1068,8 @@
             throw new ArithmeticException("Invalid Operation");
         }
         if (mcPrecision > 0) {
-            newPrecision = new MathContext(mcPrecision + elength + 1, mc
-                    .getRoundingMode());
+            newPrecision = new MathContext( mcPrecision + elength + 1,
+                    mc.getRoundingMode());
         }
         // The result is calculated as if 'n' were positive        
         accum = round(newPrecision);
@@ -935,7 +1103,10 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal negate() {
-        return new BigDecimal(unscaledValue.negate(), scale);
+        if(bitLength < 63 || (bitLength == 63 && smallValue!=Long.MIN_VALUE)) {
+            return valueOf(-smallValue,scale);
+        }
+        return new BigDecimal(getUnscaledValue().negate(), scale);
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -955,7 +1126,15 @@
 
     /** @ar.org.fitc.spec_ref */
     public int signum() {
-        return unscaledValue.signum();
+        if( bitLength < 64) {
+            return Long.signum( this.smallValue );
+        }
+        return getUnscaledValue().signum();
+    }
+    
+    private boolean isZero() {
+        //Watch out: -1 has a bitLength=0
+        return bitLength == 0 && this.smallValue != -1;
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -969,26 +1148,24 @@
         if (precision > 0) {
             return precision;
         }
-        int bitLength = unscaledValue.bitLength();
+        int bitLength = this.bitLength;
         int decimalDigits = 1; // the precision to be calculated
-        double doubleUnsc = 1; // unscaledValue in 'double'
+        double doubleUnsc = 1;  // intVal in 'double'
 
         if (bitLength < 1024) {
             // To calculate the precision for small numbers
             if (bitLength >= 64) {
-                doubleUnsc = unscaledValue.doubleValue();
-            } else if (bitLength >= 32) {
-                doubleUnsc = unscaledValue.longValue();
+                doubleUnsc = getUnscaledValue().doubleValue();
             } else if (bitLength >= 1) {
-                doubleUnsc = unscaledValue.intValue();
+                doubleUnsc = smallValue;
             }
             decimalDigits += Math.log10(Math.abs(doubleUnsc));
         } else {// (bitLength >= 1024)
             /* To calculate the precision for large numbers
-             * Note that: 2 ^(bitlength() - 1) <= unscaledValue < 10 ^(precision()) */
+             * Note that: 2 ^(bitlength() - 1) <= intVal < 10 ^(precision()) */
             decimalDigits += (bitLength - 1) * LOG10_2;
             // If after division the number isn't zero, exists an aditional digit
-            if (unscaledValue.divide(powerOf10(decimalDigits)).signum() != 0) {
+            if (getUnscaledValue().divide(Multiplication.powerOf10(decimalDigits)).signum() != 0) {
                 decimalDigits++;
             }
         }
@@ -998,12 +1175,12 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigInteger unscaledValue() {
-        return unscaledValue;
+        return getUnscaledValue();
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal round(MathContext mc) {
-        BigDecimal thisBD = new BigDecimal(unscaledValue, scale);
+        BigDecimal thisBD = new BigDecimal(getUnscaledValue(), scale);
 
         thisBD.inplaceRound(mc);
         return thisBD;
@@ -1011,18 +1188,28 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal setScale(int newScale, RoundingMode roundingMode) {
-        long diffScale = newScale - (long) scale;
-
         if (roundingMode == null) {
             throw new NullPointerException();
         }
+        long diffScale = newScale - (long)scale;
         // Let be:  'this' = [u,s]        
-        return ((diffScale >= 0)
+        if(diffScale == 0) {
+            return this;
+        }
+        if(diffScale > 0) {
         // return  [u * 10^(s2 - s), newScale]
-                ? new BigDecimal(unscaledValue.multiply(powerOf10(diffScale)),
-                        newScale)
+            if(diffScale < LONG_TEN_POW.length &&
+                    (this.bitLength + LONG_TEN_POW_BIT_LENGTH[(int)diffScale]) < 64 ) {
+                return valueOf(this.smallValue*LONG_TEN_POW[(int)diffScale],newScale);
+            }
+            return new BigDecimal(Multiplication.multiplyByTenPow(getUnscaledValue(),(int)diffScale), newScale);
+        } else { // diffScale < 0
                 // return  [u,s] / [1,newScale]  with the apropiate scale and rounding
-                : this.divide(BigDecimal.ONE, newScale, roundingMode));
+            if(this.bitLength < 64 && -diffScale < LONG_TEN_POW.length) {
+                return dividePrimitiveLongs(this.smallValue, LONG_TEN_POW[(int)-diffScale], newScale,roundingMode);
+            }
+            return divideBigIntegers(this.getUnscaledValue(),Multiplication.powerOf10(-diffScale),newScale,roundingMode);
+        }
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -1037,39 +1224,49 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal movePointLeft(int n) {
-        long newScale = scale + (long) n;
+        return movePoint(scale + (long)n);
+    }
 
-        if (signum() == 0) {
+    private BigDecimal movePoint(long newScale) {
+        if (isZero()) {
             return zeroScaledBy(Math.max(newScale, 0));
         } else {
             /* When:  'n'== Integer.MIN_VALUE  isn't possible to call to movePointRight(-n)  
              * since  -Integer.MIN_VALUE == Integer.MIN_VALUE */
-            return ((newScale >= 0) ? new BigDecimal(unscaledValue,
-                    toIntScale(newScale)) : new BigDecimal(unscaledValue
-                    .multiply(powerOf10(-newScale)), 0));
+            if(newScale >= 0) {
+                if(bitLength < 64) {
+                    return valueOf(smallValue,toIntScale(newScale));
+                } else {
+                    return new BigDecimal(getUnscaledValue(), toIntScale(newScale));
+                }
+            } else {
+                if(-newScale < LONG_TEN_POW.length &&
+                        bitLength + LONG_TEN_POW_BIT_LENGTH[(int)-newScale] < 64 ) {
+                    return valueOf(smallValue*LONG_TEN_POW[(int)-newScale],0);
+                } else {
+                    return new BigDecimal(Multiplication.multiplyByTenPow(getUnscaledValue(),(int)-newScale), 0);
+                }
+            }
         }
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal movePointRight(int n) {
-        long newScale = scale - (long) n;
-
-        if (signum() == 0) {
-            return zeroScaledBy(Math.max(newScale, 0));
-        } else {
-            // Here we have the same observation that in the movePointLeft(int) method 
-            return ((newScale >= 0) ? new BigDecimal(unscaledValue,
-                    toIntScale(newScale)) : new BigDecimal(unscaledValue
-                    .multiply(powerOf10(-newScale)), 0));
-        }
+        return movePoint(scale - (long)n);
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal scaleByPowerOfTen(int n) {
-        long newScale = scale - (long) n;
-
-        return ((signum() == 0) ? zeroScaledBy(newScale) : new BigDecimal(
-                unscaledValue, toIntScale(newScale)));
+        long newScale = scale - (long)n;
+        if(bitLength < 64) {
+            //Taking care when a 0 is to be scaled
+            if( smallValue==0  ){
+                return zeroScaledBy( newScale );
+            }
+            return valueOf(smallValue,toIntScale(newScale));
+        } else {
+            return new BigDecimal(getUnscaledValue(), toIntScale(newScale));
+        }
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -1077,12 +1274,13 @@
         int i = 1; // 1 <= i <= 18
         int lastPow = TEN_POW.length - 1;
         long newScale = scale;
-        BigInteger strippedBI = unscaledValue;
-        BigInteger[] quotAndRem;
 
-        if (signum() == 0) {
+        if (isZero()) {
             return this;
         }
+        BigInteger strippedBI = getUnscaledValue();
+        BigInteger[] quotAndRem;
+        
         // while the number is even...
         while (!strippedBI.testBit(0)) {
             // To divide by 10^i
@@ -1111,38 +1309,46 @@
     /** @ar.org.fitc.spec_ref */
     public int compareTo(BigDecimal val) {
         int thisSign = signum();
+        int valueSign = val.signum();
 
-        if (thisSign > val.signum()) {
-            return 1;
-        } else if (thisSign < val.signum()) {
-            return -1;
-        } else {// thisSign == val.signum()
+        if( thisSign == valueSign) {
+            if(this.scale == val.scale && this.bitLength<64 && val.bitLength<64 ) {
+                return (smallValue < val.smallValue) ? -1 : (smallValue > val.smallValue) ? 1 : 0;
+            }
+            long diffScale = (long)this.scale - val.scale;
             int diffPrecision = this.aproxPrecision() - val.aproxPrecision();
-            long diffScale = (long) this.scale - val.scale;
-
             if (diffPrecision > diffScale + 1) {
                 return thisSign;
             } else if (diffPrecision < diffScale - 1) {
                 return -thisSign;
             } else {// thisSign == val.signum()  and  diffPrecision is aprox. diffScale
-                BigInteger thisUnscaled = this.unscaledValue;
-                BigInteger valUnscaled = val.unscaledValue;
+                BigInteger thisUnscaled = this.getUnscaledValue();
+                BigInteger valUnscaled = val.getUnscaledValue();
                 // If any of both precision is bigger, append zeros to the shorter one
                 if (diffScale < 0) {
-                    thisUnscaled = thisUnscaled.multiply(powerOf10(-diffScale));
+                    thisUnscaled = thisUnscaled.multiply(Multiplication.powerOf10(-diffScale));
                 } else if (diffScale > 0) {
-                    valUnscaled = valUnscaled.multiply(powerOf10(diffScale));
+                    valUnscaled = valUnscaled.multiply(Multiplication.powerOf10(diffScale));
                 }
                 return thisUnscaled.compareTo(valUnscaled);
             }
+        } else if (thisSign < valueSign) {
+            return -1;
+        } else  {
+            return 1;
         }
     }
 
     /** @ar.org.fitc.spec_ref */
     @Override
     public boolean equals(Object x) {
-        return ((x instanceof BigDecimal) && (((BigDecimal) x).scale == scale) && (((BigDecimal) x).unscaledValue
-                .equals(unscaledValue)));
+        return ((x instanceof BigDecimal)
+        && (((BigDecimal)x).scale == scale)
+        && (((BigDecimal)x).bitLength == bitLength)
+        && (bitLength < 64 ?
+            (((BigDecimal)x).smallValue == smallValue)
+            : (((BigDecimal)x).getUnscaledValue().equals(getUnscaledValue())))
+            );
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -1160,7 +1366,7 @@
     public int hashCode() {
         /* Take the 24 trailing bits of BigInteger hashcode
          * and the 8 trailing bits of scale. */
-        return ((unscaledValue.hashCode() << 24) | (0xFF & scale));
+        return ((getUnscaledValue().hashCode() << 24) | (0xFF & scale));
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -1169,13 +1375,17 @@
         if (toStringImage != null) {
             return toStringImage;
         }
-        String intString = unscaledValue.toString();
+        if(bitLength < 32) {
+            toStringImage = Conversion.toDecimalScaledString(smallValue,scale);
+            return toStringImage;
+        }
+        String intString = getUnscaledValue().toString();
         if (scale == 0) {
             return intString;
         }
-        int begin = (unscaledValue.signum() < 0) ? 2 : 1;
+        int begin = (getUnscaledValue().signum() < 0) ? 2 : 1;
         int end = intString.length();
-        long exponent = -(long) scale + end - begin;
+        long exponent = -(long)scale + end - begin;
         StringBuffer result = new StringBuffer();
 
         result.append(intString);
@@ -1184,7 +1394,7 @@
                 result.insert(end - scale, '.');
             } else {
                 result.insert(begin - 1, "0.");
-                result.insert(begin + 1, CH_ZEROS, 0, -(int) exponent - 1);
+                result.insert(begin + 1, CH_ZEROS, 0, -(int)exponent - 1);
             }
         } else {
             if (end - begin >= 1) {
@@ -1203,13 +1413,13 @@
 
     /** @ar.org.fitc.spec_ref */
     public String toEngineeringString() {
-        String intString = unscaledValue.toString();
+        String intString = getUnscaledValue().toString();
         if (scale == 0) {
             return intString;
         }
-        int begin = (unscaledValue.signum() < 0) ? 2 : 1;
+        int begin = (getUnscaledValue().signum() < 0) ? 2 : 1;
         int end = intString.length();
-        long exponent = -(long) scale + end - begin;
+        long exponent = -(long)scale + end - begin;
         StringBuffer result = new StringBuffer(intString);
 
         if ((scale > 0) && (exponent >= -6)) {
@@ -1217,15 +1427,15 @@
                 result.insert(end - scale, '.');
             } else {
                 result.insert(begin - 1, "0.");
-                result.insert(begin + 1, CH_ZEROS, 0, -(int) exponent - 1);
+                result.insert(begin + 1, CH_ZEROS, 0, -(int)exponent - 1);
             }
         } else {
             int delta = end - begin;
-            int rem = (int) (exponent % 3);
+            int rem = (int)(exponent % 3);
 
             if (rem != 0) {
                 // adjust exponent so it is a multiple of three
-                if (unscaledValue.signum() == 0) {
+                if (getUnscaledValue().signum() == 0) {
                     // zero value
                     rem = (rem < 0) ? -rem : 3 - rem;
                     exponent += rem;
@@ -1239,7 +1449,6 @@
                     for (int i = rem - delta; i > 0; i--) {
                         result.insert(end++, '0');
                     }
-                    System.out.println("1");
                 }
             }
             if (end - begin >= 1) {
@@ -1259,15 +1468,14 @@
 
     /** @ar.org.fitc.spec_ref */
     public String toPlainString() {
-        String intStr = unscaledValue.toString();
-        if ((scale == 0) || ((signum() == 0) && (scale < 0))) {
+        String intStr = getUnscaledValue().toString();
+        if ((scale == 0) || ((isZero()) && (scale < 0))) {
             return intStr;
         }
         int begin = (signum() < 0) ? 1 : 0;
         int delta = scale;
         // We take space for all digits, plus a possible decimal point, plus 'scale'
-        StringBuffer result = new StringBuffer(intStr.length() + 1
-                + Math.abs(scale));
+        StringBuffer result = new StringBuffer(intStr.length() + 1 + Math.abs(scale));
 
         if (begin == 1) {
             // If the number is negative, we insert a '-' character at front 
@@ -1302,30 +1510,28 @@
 
     /** @ar.org.fitc.spec_ref */
     public BigInteger toBigInteger() {
-        if ((scale == 0) || (signum() == 0)) {
-            return unscaledValue;
+        if ((scale == 0) || (isZero())) {
+            return getUnscaledValue();
         } else if (scale < 0) {
-            return unscaledValue.multiply(powerOf10(-(long) scale));
+            return getUnscaledValue().multiply(Multiplication.powerOf10(-(long)scale));
         } else {// (scale > 0)
-            return unscaledValue.divide(powerOf10(scale));
+            return getUnscaledValue().divide(Multiplication.powerOf10(scale));
         }
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigInteger toBigIntegerExact() {
-        if ((scale == 0) || (signum() == 0)) {
-            return unscaledValue;
+        if ((scale == 0) || (isZero())) {
+            return getUnscaledValue();
         } else if (scale < 0) {
-            return unscaledValue.multiply(powerOf10(-(long) scale));
+            return getUnscaledValue().multiply(Multiplication.powerOf10(-(long)scale));
         } else {// (scale > 0)
             BigInteger[] integerAndFraction;
             // An optimization before do a heavy division
-            if ((scale > aproxPrecision())
-                    || (scale > unscaledValue.getLowestSetBit())) {
+            if ((scale > aproxPrecision()) || (scale > getUnscaledValue().getLowestSetBit())) {
                 throw new ArithmeticException("Rounding necessary");
             }
-            integerAndFraction = unscaledValue
-                    .divideAndRemainder(powerOf10(scale));
+            integerAndFraction = getUnscaledValue().divideAndRemainder(Multiplication.powerOf10(scale));
             if (integerAndFraction[1].signum() != 0) {
                 // It exists a non-zero fractional part 
                 throw new ArithmeticException("Rounding necessary");
@@ -1340,7 +1546,8 @@
     public long longValue() {
         /* If scale <= -64 there are at least 64 trailing bits zero in 10^(-scale).
          * If the scale is positive and very large the long value could be zero. */
-        return ((scale <= -64) || (scale > aproxPrecision()) ? 0L
+        return ((scale <= -64) || (scale > aproxPrecision())
+        ? 0L
                 : toBigInteger().longValue());
     }
 
@@ -1354,23 +1561,24 @@
     public int intValue() {
         /* If scale <= -32 there are at least 32 trailing bits zero in 10^(-scale).
          * If the scale is positive and very large the long value could be zero. */
-        return ((scale <= -32) || (scale > aproxPrecision()) ? 0
+        return ((scale <= -32) || (scale > aproxPrecision())
+        ? 0
                 : toBigInteger().intValue());
     }
 
     /** @ar.org.fitc.spec_ref */
     public int intValueExact() {
-        return (int) valueExact(32);
+        return (int)valueExact(32);
     }
 
     /** @ar.org.fitc.spec_ref */
     public short shortValueExact() {
-        return (short) valueExact(16);
+        return (short)valueExact(16);
     }
 
     /** @ar.org.fitc.spec_ref */
     public byte byteValueExact() {
-        return (byte) valueExact(8);
+        return (byte)valueExact(8);
     }
 
     /** @ar.org.fitc.spec_ref */
@@ -1379,7 +1587,7 @@
         /* A similar code like in doubleValue() could be repeated here,
          * but this simple implementation is quite efficient. */
         float floatResult = signum();
-        long powerOfTwo = unscaledValue.bitLength() - (long) (scale / LOG10_2);
+        long powerOfTwo = this.bitLength - (long)(scale / LOG10_2);
         if ((powerOfTwo < -149) || (floatResult == 0.0f)) {
             // Cases which 'this' is very small
             floatResult *= 0.0f;
@@ -1387,7 +1595,7 @@
             // Cases which 'this' is very large
             floatResult *= Float.POSITIVE_INFINITY;
         } else {
-            floatResult = (float) doubleValue();
+            floatResult = (float)doubleValue();
         }
         return floatResult;
     }
@@ -1399,7 +1607,7 @@
         int exponent = 1076; // bias + 53
         int lowestSetBit;
         int discardedSize;
-        long powerOfTwo = unscaledValue.bitLength() - (long) (scale / LOG10_2);
+        long powerOfTwo = this.bitLength - (long)(scale / LOG10_2);
         long bits; // IEEE-754 Standard
         long tempBits; // for temporal calculations     
         BigInteger mantisa;
@@ -1411,15 +1619,15 @@
             // Cases which 'this' is very large            
             return (sign * Double.POSITIVE_INFINITY);
         }
-        mantisa = unscaledValue.abs();
+        mantisa = getUnscaledValue().abs();
         // Let be:  this = [u,s], with s > 0
         if (scale <= 0) {
             // mantisa = abs(u) * 10^s
-            mantisa = mantisa.multiply(powerOf10(-scale));
+            mantisa = mantisa.multiply(Multiplication.powerOf10(-scale));
         } else {// (scale > 0)
             BigInteger quotAndRem[];
-            BigInteger powerOfTen = powerOf10(scale);
-            int k = 100 - (int) powerOfTwo;
+            BigInteger powerOfTen = Multiplication.powerOf10(scale);
+            int k = 100 - (int)powerOfTwo;
             int compRem;
 
             if (k > 0) {
@@ -1478,10 +1686,10 @@
                 // To discard '- exponent + 1' bits
                 bits = tempBits >> 1;
                 tempBits = bits & (-1L >>> (63 + exponent));
-                bits >>= (-exponent);
+                bits >>= (-exponent );
                 // To test if after discard bits, a new carry is generated
-                if (((bits & 3) == 3)
-                        || (((bits & 1) == 1) && (tempBits != 0) && (lowestSetBit < discardedSize))) {
+                if (((bits & 3) == 3) || (((bits & 1) == 1) && (tempBits != 0)
+                && (lowestSetBit < discardedSize))) {
                     bits += 1;
                 }
                 exponent = 0;
@@ -1489,14 +1697,14 @@
             }
         }
         // Construct the 64 double bits: [sign(1), exponent(11), mantisa(52)]
-        bits = (sign & 0x8000000000000000L) | ((long) exponent << 52)
+        bits = (sign & 0x8000000000000000L) | ((long)exponent << 52)
                 | (bits & 0xFFFFFFFFFFFFFL);
         return Double.longBitsToDouble(bits);
     }
 
     /** @ar.org.fitc.spec_ref */
     public BigDecimal ulp() {
-        return new BigDecimal(BigInteger.ONE, scale);
+        return valueOf(1, scale);
     }
 
     /* Private Methods */
@@ -1515,45 +1723,43 @@
             return;
         }
         // When the number is small perform an efficient rounding
-        if (unscaledValue.bitLength() < 64) {
+        if (this.bitLength < 64) {
             smallRound(mc, discardedPrecision);
             return;
         }
         // Getting the interger part and the discarded fraction
-        BigInteger sizeOfFraction = powerOf10(discardedPrecision);
-        BigInteger[] integerAndFraction = unscaledValue
-                .divideAndRemainder(sizeOfFraction);
-        long newScale = (long) scale - discardedPrecision;
+        BigInteger sizeOfFraction = Multiplication.powerOf10(discardedPrecision);
+        BigInteger[] integerAndFraction = getUnscaledValue().divideAndRemainder(sizeOfFraction);
+        long newScale = (long)scale - discardedPrecision;
         int compRem;
         BigDecimal tempBD;
         // If the discarded fraction is non-zero, perform rounding
         if (integerAndFraction[1].signum() != 0) {
             // To check if the discarded fraction >= 0.5
-            compRem = (integerAndFraction[1].abs().shiftLeft(1)
-                    .compareTo(sizeOfFraction));
+            compRem = (integerAndFraction[1].abs().shiftLeft(1).compareTo(sizeOfFraction));
             // To look if there is a carry
-            compRem = roundingBehavior(
-                    integerAndFraction[0].testBit(0) ? 1 : 0,
-                    integerAndFraction[1].signum() * (5 + compRem), mc
-                            .getRoundingMode());
+            compRem =  roundingBehavior( integerAndFraction[0].testBit(0) ? 1 : 0,
+                    integerAndFraction[1].signum() * (5 + compRem),
+                    mc.getRoundingMode());
             if (compRem != 0) {
-                integerAndFraction[0] = integerAndFraction[0].add(BigInteger
-                        .valueOf(compRem));
+                integerAndFraction[0] = integerAndFraction[0].add(BigInteger.valueOf(compRem));
             }
             tempBD = new BigDecimal(integerAndFraction[0]);
             // If after to add the increment the precision changed, we normalize the size
             if (tempBD.precision() > mcPrecision) {
-                integerAndFraction[0] = integerAndFraction[0]
-                        .divide(BigInteger.TEN);
+                integerAndFraction[0] = integerAndFraction[0].divide(BigInteger.TEN);
                 newScale--;
             }
         }
         // To update all inernal fields
         scale = toIntScale(newScale);
-        unscaledValue = integerAndFraction[0];
         precision = mcPrecision;
+        setUnscaledValue(integerAndFraction[0]);
     }
 
+    private static int longCompareTo(long value1, long value2) {
+        return value1 > value2 ? 1 : (value1 < value2 ? -1 : 0);
+    }
     /**
      * This method implements an efficient rounding for numbers which unscaled 
      * value fits in the type <code>long</code>.
@@ -1562,9 +1768,9 @@
      * @see #round(MathContext).
      */
     private void smallRound(MathContext mc, int discardedPrecision) {
-        long sizeOfFraction = TEN_POW[discardedPrecision].longValue();
-        long newScale = (long) scale - discardedPrecision;
-        long unscaledVal = unscaledValue.longValue();
+        long sizeOfFraction = LONG_TEN_POW[discardedPrecision];
+        long newScale = (long)scale - discardedPrecision;
+        long unscaledVal = smallValue;
         // Getting the interger part and the discarded fraction
         long integer = unscaledVal / sizeOfFraction;
         long fraction = unscaledVal % sizeOfFraction;
@@ -1572,12 +1778,11 @@
         // If the discarded fraction is non-zero perform rounding
         if (fraction != 0) {
             // To check if the discarded fraction >= 0.5
-            compRem = ((new Long(Math.abs(fraction) << 1))
-                    .compareTo(sizeOfFraction));
+            compRem = longCompareTo(Math.abs(fraction) << 1,sizeOfFraction);
             // To look if there is a carry
-            integer += roundingBehavior(((int) integer) & 1, Long
-                    .signum(fraction)
-                    * (5 + compRem), mc.getRoundingMode());
+            integer += roundingBehavior( ((int)integer) & 1,
+                    Long.signum(fraction) * (5 + compRem),
+                    mc.getRoundingMode());
             // If after to add the increment the precision changed, we normalize the size
             if (Math.log10(Math.abs(integer)) >= mc.getPrecision()) {
                 integer /= 10;
@@ -1586,8 +1791,10 @@
         }
         // To update all inernal fields
         scale = toIntScale(newScale);
-        unscaledValue = BigInteger.valueOf(integer);
         precision = mc.getPrecision();
+        smallValue = integer;
+        bitLength = bitLength(integer);
+        intVal = null;
     }
 
     /**
@@ -1597,8 +1804,7 @@
      * @param roundingMode the type of rounding.
      * @return the carry propagated after rounding.
      */
-    private static int roundingBehavior(int parityBit, int fraction,
-            RoundingMode roundingMode) {
+    private static int roundingBehavior(int parityBit, int fraction, RoundingMode roundingMode) {
         int increment = 0; // the carry after rounding
 
         switch (roundingMode) {
@@ -1638,11 +1844,12 @@
     }
 
     /**
-     * If <code>unscaledValue</code> has a fractional part throws an exception, 
+     * If <code>intVal</code> has a fractional part throws an exception,
      * otherwise it counts the number of bits of value and checks if it's out 
      * of the range of the primitive type. If the number fits in the primitive
      * type returns this number as <code>long</code>, otherwise throws an
      * exception. 
+     *
      * @param bitLengthOfType number of bits of the type whose value will be 
      *         calculated exactly.
      * @return the exact value of the integer part of <code>BigDecimal</code>
@@ -1669,66 +1876,9 @@
      * @return an aproximization of <code>precision()</code> value
      */
     private int aproxPrecision() {
-        return ((precision > 0) ? precision
-                : (int) ((unscaledValue.bitLength() - 1) * LOG10_2)) + 1;
-    }
-
-    /**
-     * It calculates a power of ten, which exponent could be out of 32-bit range.
-     * Note that internally this method will be used in the worst case with
-     * an exponent equals to: <code>Integer.MAX_VALUE - Integer.MIN_VALUE</code>.
-     * @param exp the exponent of power of ten, it must be positive.
-     * @return a <code>BigInteger</code> with value <code>10^exp</code>.
-     */
-    private static BigInteger powerOf10(long exp) {
-        // PRE: exp >= 0
-        int intExp = (int) exp;
-        // "SMALL POWERS"
-        if (exp < TEN_POW.length) {
-            // The largest power that fit in 'long' type
-            return TEN_POW[intExp];
-        } else if (exp <= 50) {
-            // To calculate:    10^exp
-            return BigInteger.TEN.pow(intExp);
-        } else if (exp <= 1000) {
-            // To calculate:    5^exp * 2^exp 
-            return FIVE_POW[1].pow(intExp).shiftLeft(intExp);
-        }
-        // "LARGE POWERS"  
-        /* To check if there is free memory to allocate a BigInteger
-         * of the estimated size (measured in bytes) */
-        long byteArraySize = 1 + (long) (exp / (8 * LOG10_2));
-
-        if (byteArraySize > Runtime.getRuntime().freeMemory()) {
-            throw new OutOfMemoryError("power of ten too big");
-        }
-        if (exp <= Integer.MAX_VALUE) {
-            // To calculate:    5^exp * 2^exp
-            return FIVE_POW[1].pow(intExp).shiftLeft(intExp);
-        } else {/* "HUGE POWERS"
-         * Probably this branch won't be executed  
-         * since the power of ten is too big. */
-            // To calculate:    5^exp
-            BigInteger powerOfFive = FIVE_POW[1].pow(Integer.MAX_VALUE);
-            BigInteger res = powerOfFive;
-            long longExp = exp - Integer.MAX_VALUE;
-
-            intExp = (int) (exp % Integer.MAX_VALUE);
-            while (longExp > Integer.MAX_VALUE) {
-                res = res.multiply(powerOfFive);
-                longExp -= Integer.MAX_VALUE;
-            }
-            res = res.multiply(FIVE_POW[1].pow(intExp));
-            // To calculate:    5^exp << exp             
-            res = res.shiftLeft(Integer.MAX_VALUE);
-            longExp = exp - Integer.MAX_VALUE;
-            while (longExp > Integer.MAX_VALUE) {
-                res = res.shiftLeft(Integer.MAX_VALUE);
-                longExp -= Integer.MAX_VALUE;
-            }
-            res = res.shiftLeft(intExp);
-            return res;
-        }
+        return ((precision > 0)
+        ? precision
+                : (int)((this.bitLength - 1) * LOG10_2)) + 1;
     }
 
     /**
@@ -1747,7 +1897,7 @@
         } else if (longScale > Integer.MAX_VALUE) {
             throw new ArithmeticException("Underflow");
         } else {
-            return (int) longScale;
+            return (int)longScale;
         }
     }
 
@@ -1763,28 +1913,52 @@
      * @see #scale
      */
     private static BigDecimal zeroScaledBy(long longScale) {
-        if (longScale >= 0) {
-            if (longScale < ZERO_SCALED_BY.length) {
-                return ZERO_SCALED_BY[(int) longScale];
-            } else {
-                return new BigDecimal(BigInteger.ZERO,
-                        (longScale <= Integer.MAX_VALUE) ? (int) longScale
-                                : Integer.MAX_VALUE);
+        if (longScale == (int) longScale) {
+            return valueOf(0,(int)longScale);
             }
+        if (longScale >= 0) {
+            return new BigDecimal( 0, Integer.MAX_VALUE);
         } else {
-            return new BigDecimal(BigInteger.ZERO,
-                    (longScale >= Integer.MIN_VALUE) ? (int) longScale
-                            : Integer.MIN_VALUE);
+            return new BigDecimal( 0, Integer.MIN_VALUE);
         }
     }
 
     /** @ar.org.fitc.spec_ref */
-    private void readObject(ObjectInputStream in) throws IOException,
-            ClassNotFoundException {
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
-        if (unscaledValue == null) {
+        if (getUnscaledValue() == null) {
             throw new StreamCorruptedException("null unscaled value");
         }
     }
 
+    private BigInteger getUnscaledValue() {
+        if(intVal == null) {
+            intVal = BigInteger.valueOf(smallValue);
+        }
+        return intVal;
+    }
+    
+    private void setUnscaledValue(BigInteger unscaledValue) {
+        this.intVal = unscaledValue;
+        this.bitLength = unscaledValue.bitLength();
+        if(this.bitLength < 64) {
+            this.smallValue = unscaledValue.longValue();
+        }
+    }
+    
+    private static int bitLength(long smallValue) {
+        if(smallValue < 0) {
+            smallValue = ~smallValue;
+        }
+        return 64 - Long.numberOfLeadingZeros(smallValue);
+    }
+    
+    private static int bitLength(int smallValue) {
+        if(smallValue < 0) {
+            smallValue = ~smallValue;
+        }
+        return 32 - Integer.numberOfLeadingZeros(smallValue);
+    }
+    
 }
+

Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigInteger.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigInteger.java?rev=436649&r1=436648&r2=436649&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigInteger.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BigInteger.java Thu Aug 24 21:47:33 2006
@@ -22,11 +22,8 @@
 import java.io.Serializable;
 
 /**
- * @author Daniel Fridlender
- * @author Matthias Gallé
- * @author Mariano Heredia
- * @author Miguel Vasquez
- * 
+ * @author Intel Middleware Product Division
+ * @author Instituto Tecnologico de Cordoba
  * @ar.org.fitc.spec_ref 
  */
 public class BigInteger extends Number implements Comparable<BigInteger>,
@@ -268,7 +265,11 @@
     /** @ar.org.fitc.spec_ref */
     public static BigInteger valueOf(long val) {
         if (val < 0) {
+            if(val != -1) {
             return new BigInteger(-1, -val);
+            } else {
+                return MINUS_ONE;
+            }
         } else if (val <= 10) {
             return SMALL_VALUES[(int) val];
         } else {// (val > 10)

Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BitLevel.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BitLevel.java?rev=436649&r1=436648&r2=436649&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BitLevel.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/BitLevel.java Thu Aug 24 21:47:33 2006
@@ -30,10 +30,8 @@
  * All operations are provided in immutable way, and some in both mutable and
  * immutable.
  * 
- * @author Daniel Fridlender
- * @author Matthias Gallé
- * @author Mariano Heredia
- * @author Miguel Vasquez
+ * @author Intel Middleware Product Division
+ * @author Instituto Tecnologico de Cordoba
  */
 class BitLevel {
 

Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Conversion.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Conversion.java?rev=436649&r1=436648&r2=436649&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Conversion.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Conversion.java Thu Aug 24 21:47:33 2006
@@ -19,10 +19,8 @@
  * Static library that provides {@link BigInteger} base conversion from/to any
  * integer represented in an {@link java.lang.String} Object.
  * 
- * @author Daniel Fridlender
- * @author Matthias Gallé
- * @author Mariano Heredia
- * @author Miguel Vasquez
+ * @author Intel Middleware Product Division
+ * @author Instituto Tecnologico de Cordoba
  */
 class Conversion {
 
@@ -352,6 +350,107 @@
         }
     }
 
+    /* can process only 32-bit numbers */
+    static String toDecimalScaledString(long value, int scale) {
+        int resLengthInChars;
+        int currentChar;
+        char result[];
+        boolean negNumber = value < 0;
+        if(negNumber) {
+            value = -value;
+        }
+        if (value == 0) {
+            switch (scale) {
+                case 0: return "0";
+                case 1: return "0.0";
+                case 2: return "0.00";
+                case 3: return "0.000";
+                case 4: return "0.0000";
+                case 5: return "0.00000";
+                case 6: return "0.000000";
+                default:
+                    StringBuffer result1 = new StringBuffer();
+                    if (scale  < 0) {
+                        result1.append("0E+");
+                    } else {
+                        result1.append("0E");
+                    }
+                    result1.append( (scale == Integer.MIN_VALUE) ? "2147483648" : Integer.toString(-scale));
+                    return result1.toString();
+            }
+        } else {
+            // one 32-bit unsigned value may contains 10 decimal digits
+            resLengthInChars = 18;
+            // Explanation why +1+7:
+            // +1 - one char for sign if needed.
+            // +7 - For "special case 2" (see below) we have 7 free chars for
+            //  inserting necessary scaled digits.
+            result = new char[resLengthInChars+1];
+            //  alocated [resLengthInChars+1] charactes.
+            // a free latest character may be used for "special case 1" (see below)
+            currentChar = resLengthInChars;
+            long v = value;
+            do {
+                long prev = v;
+                v /= 10;
+                result[--currentChar] = (char) (0x0030 + (prev - v * 10));
+            } while (v != 0);
+        }
+        
+        long exponent = (long)resLengthInChars - (long)currentChar - (long)scale - 1L;
+        if (scale == 0) {
+            if (negNumber) {
+                result[--currentChar] = '-';
+            }
+            return new String(result, currentChar, resLengthInChars - currentChar);
+        }
+        if (scale > 0 && exponent >= -6) {
+            if (exponent >= 0) {
+                // special case 1
+                int insertPoint = currentChar + (int) exponent ;
+                for(int j=resLengthInChars-1; j>=insertPoint; j--) {
+                    result[j+1] = result[j];
+                }
+                result[++insertPoint]='.';
+                if (negNumber) {
+                    result[--currentChar] = '-';
+                }
+                return new String(result, currentChar, resLengthInChars - currentChar + 1);
+            } else {
+                // special case 2
+                for (int j = 2; j < -exponent + 1; j++) {
+                    result[--currentChar] = '0';
+                }
+                result[--currentChar] = '.';
+                result[--currentChar] = '0';
+                if (negNumber) {
+                    result[--currentChar] = '-';
+                }
+                return new String(result, currentChar, resLengthInChars - currentChar);
+            }
+        } else {
+            int startPoint = currentChar + 1;
+            int endPoint = resLengthInChars;
+            StringBuffer result1 = new StringBuffer(16+endPoint-startPoint);
+            if (negNumber) {
+                result1.append('-');
+            }
+            if (endPoint - startPoint >= 1) {
+                result1.append(result[currentChar]);
+                result1.append('.');
+                result1.append(result,currentChar+1,resLengthInChars - currentChar-1);
+            } else {
+                result1.append(result,currentChar,resLengthInChars - currentChar);
+            }
+            result1.append('E');
+            if (exponent > 0) {
+                result1.append('+');
+            }
+            result1.append(Long.toString(exponent));
+            return result1.toString();
+        }
+    }
+    
     static long divideLongByBillion(long a) {
         long quot;
         long rem;

Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Division.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Division.java?rev=436649&r1=436648&r2=436649&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Division.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Division.java Thu Aug 24 21:47:33 2006
@@ -35,12 +35,10 @@
  * <li>Modular inverse of a {@link BigInteger} numbers.</li>
  * </ul>
  * </li>
- * </ul>
+ *</ul>
  * 
- * @author Daniel Fridlender
- * @author Matthias Gallé
- * @author Mariano Heredia
- * @author Miguel Vasquez
+ * @author Intel Middleware Product Division
+ * @author Instituto Tecnológico de Córdoba
  */
 class Division {
 

Modified: incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Elementary.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Elementary.java?rev=436649&r1=436648&r2=436649&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Elementary.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/math/src/main/java/java/math/Elementary.java Thu Aug 24 21:47:33 2006
@@ -24,13 +24,10 @@
  * <li>Subtraction.</li>
  * <li>Comparison.</li>
  * </ul>
- * In addition to this, some <i><b>Inplace</b></i> (mutable) methods are
- * provided.
+ * In addition to this, some <i><b>Inplace</b></i> (mutable) methods are provided.
  * 
- * @author Daniel Fridlender
- * @author Matthias Gallé
- * @author Mariano Heredia
- * @author Miguel Vasquez
+ * @author Intel Middleware Product Division
+ * @author Instituto Tecnológico de Córdoba
  */
 class Elementary {
 



Mime
View raw message