Better resize strategy for the dynamic array

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/util/DynamicIntArray.java

@@ -9,6 +9,11 @@
  */
 public final class DynamicIntArray {
 
+    // Growth factor for array expansion; not too much, the point of this class is to avoid excessive memory use.
+    private static final double GROWTH_FACTOR = 1.2;
+    // Minimum capacity increment to avoid small incremental growth
+    private static final int MIN_CAPACITY_INCREMENT = 10;
+
     private final int maxLength;
     private int[] array;
     private int firstIndex;
@@ -33,7 +38,8 @@ public DynamicIntArray(int maxLength) {
     /**
      * Sets the value at the specified index.
      * If this is the first element, the array is created.
-     * If the index is lower than the current firstIndex, the array is reallocated.
+     * If the index is lower than the current firstIndex or higher than the current lastIndex,
+     * the array is reallocated with a growth strategy to reduce frequent reallocations.
      *
      * @param index the index at which to set the value
      * @param value the value to set
@@ -43,42 +49,81 @@ public void set(int index, int value) {
             throw new ArrayIndexOutOfBoundsException(index);
         }
         if (array == null) {
-            // First element, create the array with size 1
-            array = new int[1];
+            // First element, create the array with initial capacity
+            var initialCapacity = Math.min(MIN_CAPACITY_INCREMENT, maxLength);
+            array = new int[initialCapacity];
             firstIndex = index;
             lastIndex = index;
             array[0] = value;
         } else if (index < firstIndex) {
             // New index is lower than first index, need to reallocate
-            int newSize = lastIndex - index + 1;
-            int[] newArray = new int[newSize];
+            var currentSize = lastIndex - firstIndex + 1;
+            var offset = firstIndex - index;
 
-            // Copy existing elements to new array with offset
-            int offset = firstIndex - index;
-            System.arraycopy(array, 0, newArray, offset, lastIndex - firstIndex + 1);
+            // Calculate new capacity with growth strategy
+            var requiredCapacity = currentSize + offset;
+            var newCapacity = calculateNewCapacity(requiredCapacity);
 
-            // Update first index and array
-            firstIndex = index;
+            // Copy existing elements to new array with offset
+            var newArray = new int[newCapacity];
+            System.arraycopy(array, 0, newArray, offset, currentSize);
             array = newArray;
+            firstIndex = index;
             array[0] = value;
         } else if (index > lastIndex) {
             // New index is higher than last index, need to expand
-            int newSize = index - firstIndex + 1;
-            int[] newArray = new int[newSize];
+            var currentSize = lastIndex - firstIndex + 1;
+            var newSize = index - firstIndex + 1;
+
+            if (newSize > array.length) {
+                // Calculate new capacity with growth strategy
+                var newCapacity = calculateNewCapacity(newSize);
 
-            // Copy existing elements to new array
-            System.arraycopy(array, 0, newArray, 0, array.length);
+                // Copy existing elements to new array
+                var newArray = new int[newCapacity];
+                System.arraycopy(array, 0, newArray, 0, currentSize);
+                array = newArray;
+            }
 
-            // Update last index and array
+            // Update last index
             lastIndex = index;
-            array = newArray;
             array[index - firstIndex] = value;
         } else {
             // Index is within existing range
             array[index - firstIndex] = value;
         }
     }
 
+    /**
+     * Calculates the new capacity based on the required capacity and growth strategy.
+     * 
+     * @param requiredCapacity the minimum capacity needed
+     * @return the new capacity
+     */
+    private int calculateNewCapacity(int requiredCapacity) {
+        var currentCapacity = array != null ? array.length : 0;
+
+        if (requiredCapacity <= currentCapacity) {
+            return currentCapacity;
+        }
+
+        // Calculate new capacity using growth factor
+        var newCapacity = (int) (currentCapacity * GROWTH_FACTOR);
+
+        // Ensure minimum increment
+        if (newCapacity - currentCapacity < MIN_CAPACITY_INCREMENT) {
+            newCapacity = currentCapacity + MIN_CAPACITY_INCREMENT;
+        }
+
+        // Ensure new capacity is at least the required capacity
+        if (newCapacity < requiredCapacity) {
+            newCapacity = requiredCapacity;
+        }
+
+        // Ensure new capacity doesn't exceed maxLength
+        return Math.min(newCapacity, maxLength);
+    }
+
     /**
      * Gets the value at the specified index.
      *
@@ -144,10 +189,19 @@ int length() {
         return lastIndex + 1;
     }
 
+    /**
+     * Clears the array by setting all values to 0.
+     * The array structure is preserved, only the values are reset.
+     */
     public void clear() {
-        // Fill rather than reallocate.
-        // We keep the original bounds, assuming the array is likely to be filled up again.
-        Arrays.fill(array, 0);
+        // If array is null, there's nothing to clear
+        if (array == null) {
+            return;
+        }
+
+        // Only clear the used portion of the array (from firstIndex to lastIndex)
+        // This is more efficient for large arrays with sparse indices
+        Arrays.fill(array, 0, lastIndex - firstIndex + 1, 0);
     }
 
-}
+}

core/src/test/java/ai/timefold/solver/core/impl/util/DynamicIntArrayTest.java

@@ -310,4 +310,87 @@ void testWithSparseIndices() {
             assertThat(array.length()).isEqualTo(1001); // 0-1000 inclusive
         }
     }
-}
+
+    @Nested
+    @DisplayName("Clear method tests")
+    class ClearMethodTests {
+
+        @Test
+        @DisplayName("Clear on empty array does nothing")
+        void clearEmptyArray() {
+            var array = new DynamicIntArray();
+
+            // Should not throw an exception
+            array.clear();
+
+            assertThat(array.length()).isZero();
+        }
+
+        @Test
+        @DisplayName("Clear resets all values to 0 but preserves array structure")
+        void clearResetsValues() {
+            var array = new DynamicIntArray();
+            array.set(5, 24);
+            array.set(10, 42);
+
+            array.clear();
+
+            // Values should be reset to 0
+            assertThat(array.get(5)).isZero();
+            assertThat(array.get(10)).isZero();
+
+            // Array structure should be preserved
+            assertThat(array.getFirstIndex()).isEqualTo(5);
+            assertThat(array.getLastIndex()).isEqualTo(10);
+            assertThat(array.containsIndex(5)).isTrue();
+            assertThat(array.containsIndex(10)).isTrue();
+            assertThat(array.length()).isEqualTo(11); // 0-10 inclusive
+        }
+
+        @Test
+        @DisplayName("Clear and then set new values")
+        void clearAndSetNewValues() {
+            var array = new DynamicIntArray();
+            array.set(5, 24);
+            array.set(10, 42);
+
+            array.clear();
+
+            // Set new values
+            array.set(7, 99);
+
+            // New values should be set correctly
+            assertThat(array.get(7)).isEqualTo(99);
+
+            // Old indices should still be in the array but with value 0
+            assertThat(array.get(5)).isZero();
+            assertThat(array.get(10)).isZero();
+
+            // Array structure should be updated
+            assertThat(array.getFirstIndex()).isEqualTo(5);
+            assertThat(array.getLastIndex()).isEqualTo(10);
+        }
+
+        @Test
+        @DisplayName("Clear with sparse indices")
+        void clearWithSparseIndices() {
+            var array = new DynamicIntArray();
+            array.set(10, 1);
+            array.set(100, 2);
+            array.set(1000, 3);
+
+            array.clear();
+
+            // All values should be reset to 0
+            assertThat(array.get(10)).isZero();
+            assertThat(array.get(100)).isZero();
+            assertThat(array.get(1000)).isZero();
+
+            // Array structure should be preserved
+            assertThat(array.getFirstIndex()).isEqualTo(10);
+            assertThat(array.getLastIndex()).isEqualTo(1000);
+            assertThat(array.length()).isEqualTo(1001); // 0-1000 inclusive
+        }
+    }
+
+}