Optimize CompressedBigDecimal compareTo() (#13086)

Optimizes the compareTo() function in
CompressedBigDecimal. It directly compares the int[] rather than
creating BigDecimal objects and using its compareTo.

It handles unequal sized CBDs, but does require
the scales to match.

extensions-contrib/compressed-bigdecimal/src/main/java/org/apache/druid/compressedbigdecimal/CompressedBigDecimal.java

@@ -19,6 +19,8 @@
 
 package org.apache.druid.compressedbigdecimal;
 
+import org.apache.druid.java.util.common.IAE;
+
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Arrays;
@@ -241,6 +243,16 @@ public abstract class CompressedBigDecimal extends Number implements Comparable<
     return signumInternal(getArraySize(), this, CompressedBigDecimal::getArrayEntry);
   }
 
+  public boolean isNegative()
+  {
+    return getArrayEntry(getArraySize() - 1) < 0;
+  }
+
+  public boolean isPositive()
+  {
+    return !isNegative();
+  }
+
   /**
    * Internal implementation if signum.
    * For the Provided Compressed big decimal value it checks and returns
@@ -271,16 +283,79 @@ public abstract class CompressedBigDecimal extends Number implements Comparable<
     }
   }
 
-  /* (non-Javadoc)
-   * @see java.lang.Comparable#compareTo(java.lang.Object)
-   */
   @Override
   public int compareTo(CompressedBigDecimal o)
+  {
+    return compareTo(o, false);
+  }
+
+  public int compareTo(CompressedBigDecimal o, boolean expectOptimized)
   {
     if (super.equals(o)) {
       return 0;
+    } else if (getScale() == o.getScale()) {
+      return directCompareCompressedBigDecimal(this, o);
+    } else {
+      if (expectOptimized) {
+        throw new IAE("expected optimized path");
+      }
+
+      return this.toBigDecimal().compareTo(o.toBigDecimal());
     }
-    return this.toBigDecimal().compareTo(o.toBigDecimal());
+  }
+
+  /**
+   * performs a subtraction of lhs - rhs to compare elements
+   *
+   * @param lhs
+   * @param rhs
+   * @return
+   */
+  private static int directCompareCompressedBigDecimal(CompressedBigDecimal lhs, CompressedBigDecimal rhs)
+  {
+    // this short-circuit serves two functions: 1. it speeds up comparison in +/- cases 2. it avoids the case of
+    // overflow of positive - negative and negative - positive. p - p and n - n both fit in the given allotment of ints
+    if (lhs.isPositive() && rhs.isNegative()) {
+      return 1;
+    } else if (lhs.isNegative() && rhs.isPositive()) {
+      return -1;
+    }
+
+    int size = Math.max(lhs.getArraySize(), rhs.getArraySize());
+    int[] result = new int[size];
+    int borrow = 0;
+    // for each argument, if it's negative, our extension will be -1/INT_MASK (all 1s). else, all 0s
+    long lhsExtension = lhs.getArrayEntry(lhs.getArraySize() - 1) < 0 ? INT_MASK : 0;
+    long rhsExtension = rhs.getArrayEntry(rhs.getArraySize() - 1) < 0 ? INT_MASK : 0;
+    boolean nonZeroValues = false;
+
+    for (int i = 0; i < size; i++) {
+      // "dynamically" extend lhs/rhs if it's shorter than the other using extensions computed above
+      long leftElement = i < lhs.getArraySize() ? (INT_MASK & lhs.getArrayEntry(i)) : lhsExtension;
+      long rightElement = i < rhs.getArraySize() ? (INT_MASK & rhs.getArrayEntry(i)) : rhsExtension;
+      long resultElement = leftElement - rightElement - borrow;
+
+      borrow = 0;
+
+      if (resultElement < 0) {
+        borrow = 1;
+        resultElement += 1L << 32;
+      }
+
+      result[i] = (int) resultElement;
+
+      if (!nonZeroValues && resultElement != 0) {
+        nonZeroValues = true;
+      }
+    }
+
+    int signum = 0;
+
+    if (nonZeroValues) {
+      signum = result[size - 1] < 0 ? -1 : 1;
+    }
+
+    return signum;
   }
 
   @Override

extensions-contrib/compressed-bigdecimal/src/test/java/org/apache/druid/compressedbigdecimal/ArrayCompressedBigDecimalTest.java

@@ -19,6 +19,8 @@
 
 package org.apache.druid.compressedbigdecimal;
 
+import org.apache.druid.java.util.common.IAE;
+import org.junit.Assert;
 import org.junit.Test;
 
 import java.math.BigDecimal;
@@ -139,6 +141,126 @@ public class ArrayCompressedBigDecimalTest
     assertEquals(Integer.MIN_VALUE, array[0]);
   }
 
+  @Test
+  public void testCompareToOptimization()
+  {
+    ArrayCompressedBigDecimal d1 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d2 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d3 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d4 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    // leave this as 0
+    ArrayCompressedBigDecimal d5 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+
+    d1.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(Integer.MAX_VALUE)), d1.getScale()));
+    d2.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(-2L * Integer.MAX_VALUE)), d2.getScale()));
+    d3.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d3.getScale()));
+    d4.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d4.getScale()));
+
+    Assert.assertEquals(-1, d2.compareTo(d1, true));
+    Assert.assertEquals(1, d1.compareTo(d2, true));
+    Assert.assertEquals(0, d3.compareTo(d4, true));
+    Assert.assertEquals(0, d4.compareTo(d3, true));
+    Assert.assertEquals(-1, d1.compareTo
+                                  (d3, true));
+    Assert.assertEquals(1, d3.compareTo(d1, true));
+    Assert.assertEquals(-1, d2.compareTo(d3, true));
+    Assert.assertEquals(1, d3.compareTo(d2, true));
+    Assert.assertEquals(1, d5.compareTo(d2, true));
+    Assert.assertEquals(-1, d2.compareTo(d5, true));
+    Assert.assertEquals(-1, d5.compareTo(d3, true));
+    Assert.assertEquals(1, d3.compareTo(d5, true));
+  }
+
+  @Test(expected = IAE.class)
+  public void testCompareToFailOptimized()
+  {
+    ArrayCompressedBigDecimal d1 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d2 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE + 1
+    );
+
+    // size doesn't match, so an IAE will be thrown
+    d1.compareTo(d2, true);
+  }
+
+  @Test
+  public void testCompareToOptimizedUnequalSizes()
+  {
+    ArrayCompressedBigDecimal d1 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE + 1,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d2 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE + 2,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d3 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE + 3,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    ArrayCompressedBigDecimal d4 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE + 4,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+    // leave this as 0
+    ArrayCompressedBigDecimal d5 = ArrayCompressedBigDecimal.allocate(
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SIZE + 5,
+        CompressedBigDecimalAggregatorFactory.DEFAULT_SCALE
+    );
+
+    d1.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(Integer.MAX_VALUE)), d1.getScale()));
+    d2.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(-8L * Integer.MAX_VALUE)), d2.getScale()));
+    d3.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d3.getScale()));
+    d4.accumulate(Utils.scaleUp(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d4.getScale()));
+
+    Assert.assertEquals(-1, d2.compareTo(d1, true));
+    Assert.assertEquals(1, d1.compareTo(d2, true));
+    Assert.assertEquals(0, d3.compareTo(d4, true));
+    Assert.assertEquals(0, d4.compareTo(d3, true));
+    Assert.assertEquals(-1, d1.compareTo(d3, true));
+    Assert.assertEquals(1, d3.compareTo(d1, true));
+    Assert.assertEquals(-1, d2.compareTo(d3, true));
+    Assert.assertEquals(1, d3.compareTo(d2, true));
+    Assert.assertEquals(1, d5.compareTo(d2, true));
+    Assert.assertEquals(-1, d2.compareTo(d5, true));
+    Assert.assertEquals(-1, d5.compareTo(d3, true));
+    Assert.assertEquals(1, d3.compareTo(d5, true));
+  }
+
+  @Test
+  public void testCompareToOverflow()
+  {
+    CompressedBigDecimal maxPositive = ArrayCompressedBigDecimal.wrap(new int[]{0, 0x7FFFFFFF}, 0);
+    CompressedBigDecimal minNegative = ArrayCompressedBigDecimal.wrap(new int[]{-1, 0x80000000}, 0);
+    CompressedBigDecimal one = ArrayCompressedBigDecimal.wrap(new int[]{1, 0}, 0);
+    CompressedBigDecimal negativeOne = ArrayCompressedBigDecimal.wrap(new int[]{-1, -1}, 0);
+
+    // compareTo skips subtraction in overflow cases
+    Assert.assertEquals(1, maxPositive.compareTo(minNegative));
+    Assert.assertEquals(-1, minNegative.compareTo(maxPositive));
+    Assert.assertEquals(1, maxPositive.compareTo(negativeOne));
+    Assert.assertEquals(-1, minNegative.compareTo(one));
+  }
+
   /**
    * Test method for {@link ArrayCompressedBigDecimal#ArrayCompressedBigDecimal}.
    */
@@ -178,7 +300,7 @@ public class ArrayCompressedBigDecimalTest
   public void testBigDecimalConstructorUnevenMultiplePositive()
   {
     // test positive when number of bytes in BigDecimal isn't an even multiple of sizeof(int)
-    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[] {0x7f, -1, -1, -1, -1}));
+    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[]{0x7f, -1, -1, -1, -1}));
     ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
     assertEquals(0, d.getScale());
     int[] array = d.getArray();
@@ -194,7 +316,7 @@ public class ArrayCompressedBigDecimalTest
   public void testBigDecimalConstructorUnevenMultipleNegative()
   {
     // test negative when number of bytes in BigDecimal isn't an even multiple of sizeof(int)
-    BigDecimal bd = new BigDecimal(new BigInteger(-1, new byte[] {Byte.MIN_VALUE, 0, 0, 0, 0}));
+    BigDecimal bd = new BigDecimal(new BigInteger(-1, new byte[]{Byte.MIN_VALUE, 0, 0, 0, 0}));
     ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
     assertEquals(0, d.getScale());
     int[] array = d.getArray();
@@ -209,7 +331,7 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testCopyConstructor()
   {
-    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[] {0x7f, -1, -1, -1, -1}));
+    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[]{0x7f, -1, -1, -1, -1}));
     ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
 
     ArrayCompressedBigDecimal d2 = new ArrayCompressedBigDecimal(d);
@@ -224,7 +346,7 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testWrap()
   {
-    int[] array = new int[] {Integer.MAX_VALUE, -1};
+    int[] array = new int[]{Integer.MAX_VALUE, -1};
     ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(array, 0);
     assertSame(array, bd.getArray());
     assertEquals(0, bd.getScale());
@@ -249,11 +371,11 @@ public class ArrayCompressedBigDecimalTest
   {
     ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.allocate(2, 0);
 
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {0x00000001, 0}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{0x00000001, 0}, 0);
     bd.accumulate(add);
-    assertArrayEquals(new int[] {1, 0}, bd.getArray());
+    assertArrayEquals(new int[]{1, 0}, bd.getArray());
     bd.accumulate(add);
-    assertArrayEquals(new int[] {2, 0}, bd.getArray());
+    assertArrayEquals(new int[]{2, 0}, bd.getArray());
   }
 
   /**
@@ -262,13 +384,13 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testSimpleAccumulateOverflow()
   {
-    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[] {0x80000000, 0}, 0);
+    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{0x80000000, 0}, 0);
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {0x7fffffff, 0}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{0x7fffffff, 0}, 0);
-    ArrayCompressedBigDecimal add1 = ArrayCompressedBigDecimal.wrap(new int[] {0x00000001, 0}, 0);
+    ArrayCompressedBigDecimal add1 = ArrayCompressedBigDecimal.wrap(new int[]{0x00000001, 0}, 0);
     bd.accumulate(add);
-    assertArrayEquals(new int[] {0xffffffff, 0}, bd.getArray());
+    assertArrayEquals(new int[]{0xffffffff, 0}, bd.getArray());
     bd.accumulate(add1);
-    assertArrayEquals(new int[] {0, 1}, bd.getArray());
+    assertArrayEquals(new int[]{0, 1}, bd.getArray());
   }
 
   /**
@@ -277,12 +399,12 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testSimpleAccumulateUnderflow()
   {
-    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[] {0, 1}, 0);
+    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{0, 1}, 0);
 
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {-1, -1}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{-1, -1}, 0);
 
     bd.accumulate(add);
-    assertArrayEquals(new int[] {0xffffffff, 0}, bd.getArray());
+    assertArrayEquals(new int[]{0xffffffff, 0}, bd.getArray());
   }
 
   /**
@@ -291,12 +413,12 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testUnevenAccumulateUnderflow()
   {
-    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[] {0, 1}, 0);
+    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{0, 1}, 0);
 
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {-1}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{-1}, 0);
 
     bd.accumulate(add);
-    assertArrayEquals(new int[] {0xffffffff, 0}, bd.getArray());
+    assertArrayEquals(new int[]{0xffffffff, 0}, bd.getArray());
   }
 
   /**
@@ -305,12 +427,12 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testUnevenAccumulateOverflow()
   {
-    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[] {0xffffffff, 1}, 0);
+    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{0xffffffff, 1}, 0);
 
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {1}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{1}, 0);
 
     bd.accumulate(add);
-    assertArrayEquals(new int[] {0, 2}, bd.getArray());
+    assertArrayEquals(new int[]{0, 2}, bd.getArray());
   }
 
   /**
@@ -319,9 +441,9 @@ public class ArrayCompressedBigDecimalTest
   @Test(expected = IllegalArgumentException.class)
   public void testUnevenAccumulateOverflowWithTruncate()
   {
-    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[] {Integer.MAX_VALUE}, 0);
+    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{Integer.MAX_VALUE}, 0);
 
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {1, 1}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{1, 1}, 0);
 
     bd.accumulate(add);
   }
@@ -343,19 +465,19 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testToBigDecimal()
   {
-    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[] {1}, 0);
+    ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{1}, 0);
     assertEquals(BigDecimal.ONE, bd.toBigDecimal());
 
-    bd = ArrayCompressedBigDecimal.wrap(new int[] {Integer.MAX_VALUE}, 0);
+    bd = ArrayCompressedBigDecimal.wrap(new int[]{Integer.MAX_VALUE}, 0);
     assertEquals(new BigDecimal(Integer.MAX_VALUE), bd.toBigDecimal());
 
-    bd = ArrayCompressedBigDecimal.wrap(new int[] {0}, 0);
+    bd = ArrayCompressedBigDecimal.wrap(new int[]{0}, 0);
     assertEquals(BigDecimal.ZERO, bd.toBigDecimal());
-    bd = ArrayCompressedBigDecimal.wrap(new int[] {0, 0}, 0);
+    bd = ArrayCompressedBigDecimal.wrap(new int[]{0, 0}, 0);
     assertEquals(BigDecimal.ZERO, bd.toBigDecimal());
     bd = new ArrayCompressedBigDecimal(-1, 9);
     assertEquals(new BigDecimal(-1).scaleByPowerOfTen(-9), bd.toBigDecimal());
-    bd = ArrayCompressedBigDecimal.wrap(new int[] {1410065408, 2}, 9);
+    bd = ArrayCompressedBigDecimal.wrap(new int[]{1410065408, 2}, 9);
     assertEquals(new BigDecimal(10).setScale(9), bd.toBigDecimal());
   }
 
@@ -365,7 +487,7 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testBigDecimalConstructorwithByteBuffer()
   {
-    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[] {0x7f, -1, -1}));
+    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[]{0x7f, -1, -1}));
     ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
     ByteBuffer buf = ByteBuffer.allocate(4);
     CompressedBigDecimal cbd = new ByteBufferCompressedBigDecimal(buf, 0, d);
@@ -381,7 +503,7 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testSetArrayEntry()
   {
-    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[] {0x7f, -1, -1}));
+    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[]{0x7f, -1, -1}));
     ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
     d.setArrayEntry(0, 2);
     assertEquals(2, d.intValue());
@@ -393,7 +515,7 @@ public class ArrayCompressedBigDecimalTest
   @Test
   public void testCopyToBuffer()
   {
-    ByteBuffer bb = ByteBuffer.wrap(new byte[] {0, 0, 0, 0, 0, 0, 0, 4});
+    ByteBuffer bb = ByteBuffer.wrap(new byte[]{0, 0, 0, 0, 0, 0, 0, 4});
     ByteBufferCompressedBigDecimal bbdl = new ByteBufferCompressedBigDecimal(bb, 0, 1, 0);
     bbdl.setArrayEntry(0, 2);
     assertEquals(2, bbdl.intValue());
@@ -405,8 +527,6 @@ public class ArrayCompressedBigDecimalTest
   @Test(expected = IllegalArgumentException.class)
   public void testUtilsAccumulateByteBuf()
   {
-    BigDecimal bd = new BigDecimal(new BigInteger(1, new byte[] {0x7f, -1, -1}));
-    ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
     ByteBuffer buf = ByteBuffer.allocate(4);
     accumulate(buf, 0, 1, 2, new ArrayCompressedBigDecimal(new BigDecimal(Long.MAX_VALUE)));
   }
@@ -429,7 +549,7 @@ public class ArrayCompressedBigDecimalTest
   public void testUtilsAccumulateCbd()
   {
     ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.allocate(2, 0);
-    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[] {0x00000001, 0}, 0);
+    ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{0x00000001, 0}, 0);
     bd.accumulate(add);
     accumulate(bd, 1, 0);
     assertEquals("2", bd.toString());
@@ -447,12 +567,11 @@ public class ArrayCompressedBigDecimalTest
   public void testCompressedBigDecimalObjectStrategy()
   {
     ArrayCompressedBigDecimal bd;
-    ArrayCompressedBigDecimal acd = ArrayCompressedBigDecimal.wrap(new int[] {0x00000001, 0}, 0);
+    ArrayCompressedBigDecimal acd = ArrayCompressedBigDecimal.wrap(new int[]{0x00000001, 0}, 0);
     bd = acd;
     CompressedBigDecimalObjectStrategy c1 = new CompressedBigDecimalObjectStrategy();
 
-    BigDecimal d = new BigDecimal(new BigInteger(1, new byte[] {0, 0, 1}));
+    ByteBuffer bb = ByteBuffer.wrap(new byte[]{0, 0, 0, 0, 0, 0, 0, 4});
-    ByteBuffer bb = ByteBuffer.wrap(new byte[] {0, 0, 0, 0, 0, 0, 0, 4});
     CompressedBigDecimal cbl = c1.fromByteBuffer(bb, 8);
     byte[] bf = c1.toBytes(bd);
     ArrayCompressedBigDecimal cbd = new ArrayCompressedBigDecimal(new BigDecimal(new BigInteger(1, bf)));
@@ -461,5 +580,4 @@ public class ArrayCompressedBigDecimalTest
     assertEquals(0, c1.compare(bd, acd));
     assertEquals(0, cbd.intValue());
   }
-
 }