Update the behaviour of capacities

Author: rtheunissen

src/Map.php

@@ -36,6 +36,14 @@ public function __construct($values = null)
         }
     }
 
+    // /**
+    //  * @return whether capacity should be increased.
+    //  */
+    // protected function shouldIncreaseCapacity(): bool
+    // {
+    //     return count($this) > $this->capacity;
+    // }
+
     /**
      * Updates all values by applying a callback function to each value.
      *
@@ -350,7 +358,7 @@ public function put($key, $value)
             $pair->value = $value;
 
         } else {
-            $this->adjustCapacity();
+            $this->checkCapacity();
             $this->pairs[] = new Pair($key, $value);
         }
     }
@@ -400,7 +408,7 @@ private function delete(int $position)
         $value = $pair->value;
 
         array_splice($this->pairs, $position, 1, null);
-        $this->adjustCapacity();
+        $this->checkCapacity();
 
         return $value;
     }

src/PriorityQueue.php

@@ -237,7 +237,7 @@ public function pop()
 
         // Replace the root, then sift down.
         $this->setRoot($leaf);
-        $this->adjustCapacity();
+        $this->checkCapacity();
 
         return $value;
     }
@@ -269,7 +269,7 @@ private function siftUp(int $leaf)
      */
     public function push($value, int $priority)
     {
-        $this->adjustCapacity();
+        $this->checkCapacity();
 
         // Add new leaf, then sift up to maintain heap,
         $this->heap[] = new PriorityNode($value, $priority, $this->stamp++);

src/Traits/Capacity.php

@@ -9,7 +9,7 @@
 trait Capacity
 {
     /**
-     * @var int internal capacity
+     * @var integer internal capacity
      */
     private $capacity = self::MIN_CAPACITY;
 
@@ -37,27 +37,73 @@ public function allocate(int $capacity)
     }
 
     /**
-     * Called when capacity should be increased to accommodate new values.
+     * @return the structures growth factor.
      */
-    abstract protected function increaseCapacity();
+    protected function getGrowthFactor(): float
+    {
+        return 2;
+    }
 
     /**
-     * Adjusts the structure's capacity according to its current size.
+     * @return float to multiply by when decreasing capacity.
      */
-    private function adjustCapacity()
+    protected function getDecayFactor(): float
     {
-        $size = count($this);
+        return 0.5;
+    }
 
-        // Automatically truncate the allocated buffer when the size of the
-        // structure drops low enough.
-        if ($size < $this->capacity / 4) {
-            $this->capacity = max(self::MIN_CAPACITY, $this->capacity / 2);
-        } else {
+    /**
+     * @return float the ratio between size and capacity when capacity should be
+     *               decreased.
+     */
+    protected function getTruncateThreshold(): float
+    {
+        return 0.25;
+    }
 
-            // Also check if we should increase capacity when the size changes.
-            if ($size >= $this->capacity) {
-                $this->increaseCapacity();
+    /**
+     * Checks and adjusts capacity if required.
+     */
+    protected function checkCapacity()
+    {
+        if ($this->shouldIncreaseCapacity()) {
+            $this->increaseCapacity();
+        } else {
+            if ($this->shouldDecreaseCapacity()) {
+                $this->decreaseCapacity();
             }
         }
     }
+
+    /**
+     * Called when capacity should be increased to accommodate new values.
+     */
+    protected function increaseCapacity()
+    {
+        $this->capacity = max($this->count(), $this->capacity * $this->getGrowthFactor());
+    }
+
+    /**
+     * Called when capacity should be decrease if it drops below a threshold.
+     */
+    protected function decreaseCapacity()
+    {
+        $this->capacity = max(self::MIN_CAPACITY, $this->capacity  * $this->getDecayFactor());
+    }
+
+    /**
+     * @return whether capacity should be increased.
+     */
+    protected function shouldDecreaseCapacity(): bool
+    {
+        return count($this) <= $this->capacity * $this->getTruncateThreshold();
+    }
+
+    /**
+     * @return whether capacity should be increased.
+     */
+    protected function shouldIncreaseCapacity(): bool
+    {
+        return count($this) >= $this->capacity;
+    }
 }

src/Traits/GenericSequence.php

@@ -169,7 +169,8 @@ public function pop()
         }
 
         $value = array_pop($this->array);
-        $this->adjustCapacity();
+        $this->checkCapacity();
+
         return $value;
     }
 
@@ -181,7 +182,8 @@ private function pushAll($values)
         foreach ($values as $value) {
             $this->array[] = $value;
         }
-        $this->adjustCapacity();
+
+        $this->checkCapacity();
     }
 
     /**
@@ -210,7 +212,8 @@ public function remove(int $index)
         }
 
         $value = array_splice($this->array, $index, 1, null)[0];
-        $this->adjustCapacity();
+        $this->checkCapacity();
+
         return $value;
     }
 
@@ -276,7 +279,8 @@ public function shift()
         }
 
         $value = array_shift($this->array);
-        $this->adjustCapacity();
+        $this->checkCapacity();
+
         return $value;
     }
 
@@ -329,7 +333,7 @@ public function unshift(...$values)
     {
         if ($values) {
             $this->array = array_merge($values, $this->array);
-            $this->adjustCapacity();
+            $this->checkCapacity();
         }
     }
 

src/Traits/SquaredCapacity.php

@@ -38,6 +38,6 @@ public function allocate(int $capacity)
      */
     protected function increaseCapacity()
     {
-        $this->capacity = $this->square(max(count($this), $this->capacity + 1));
+        $this->capacity = $this->square(max(count($this) + 1, $this->capacity * $this->getGrowthFactor()));
     }
 }

src/Vector.php

@@ -15,17 +15,18 @@ final class Vector implements \IteratorAggregate, \ArrayAccess, Sequence
     use Traits\GenericSequence;
     use Traits\Capacity;
 
-    const MIN_CAPACITY = 10;
+    const MIN_CAPACITY = 8;
+
+    protected function getGrowthFactor(): float
+    {
+        return 1.5;
+    }
 
     /**
-     * Called when capacity should be increased to accommodate new values.
+     * @return whether capacity should be increased.
      */
-    protected function increaseCapacity()
+    protected function shouldIncreaseCapacity(): bool
     {
-        $size = count($this);
-
-        if ($size > $this->capacity) {
-            $this->capacity = max(intval($this->capacity * 1.5), $size);
-        }
+        return count($this) > $this->capacity;
     }
 }