Fix MAP-Elite algorithm binning issue with adaptive feature coordinates

- Replace fixed-scale binning with adaptive binning in _calculate_feature_coords
- Add _calculate_complexity_bin method for complexity-based binning
- Add _calculate_diversity_bin method for diversity-based binning
- Fix issue where all programs were binned into highest complexity bin
- Use actual program complexity range for adaptive binning when available
- Fall back to reasonable fixed ranges during cold start

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: claude[bot]

openevolve/database.py

@@ -636,7 +636,7 @@ def _calculate_feature_coords(self, program: Program) -> List[int]:
             if dim == "complexity":
                 # Use code length as complexity measure
                 complexity = len(program.code)
-                bin_idx = min(int(complexity / 1000 * self.feature_bins), self.feature_bins - 1)
+                bin_idx = self._calculate_complexity_bin(complexity)
                 coords.append(bin_idx)
             elif dim == "diversity":
                 # Use average edit distance to other programs
@@ -650,9 +650,7 @@ def _calculate_feature_coords(self, program: Program) -> List[int]:
                         calculate_edit_distance(program.code, other.code)
                         for other in sample_programs
                     ) / len(sample_programs)
-                    bin_idx = min(
-                        int(avg_distance / 1000 * self.feature_bins), self.feature_bins - 1
-                    )
+                    bin_idx = self._calculate_diversity_bin(avg_distance)
                 coords.append(bin_idx)
             elif dim == "score":
                 # Use average of numeric metrics
@@ -677,6 +675,87 @@ def _calculate_feature_coords(self, program: Program) -> List[int]:
         )
         return coords
 
+    def _calculate_complexity_bin(self, complexity: int) -> int:
+        """
+        Calculate the bin index for a given complexity value using adaptive binning.
+        
+        Args:
+            complexity: The complexity value (code length)
+            
+        Returns:
+            Bin index in range [0, self.feature_bins - 1]
+        """
+        if len(self.programs) < 2:
+            # Cold start: use fixed range binning
+            # Assume reasonable range of 0-10000 characters for code length
+            max_complexity = 10000
+            min_complexity = 0
+        else:
+            # Adaptive binning: use actual range from existing programs
+            existing_complexities = [len(p.code) for p in self.programs.values()]
+            min_complexity = min(existing_complexities)
+            max_complexity = max(existing_complexities)
+            
+            # Ensure range is not zero
+            if max_complexity == min_complexity:
+                max_complexity = min_complexity + 1
+        
+        # Normalize complexity to [0, 1] range
+        if max_complexity > min_complexity:
+            normalized = (complexity - min_complexity) / (max_complexity - min_complexity)
+        else:
+            normalized = 0.0
+        
+        # Clamp to [0, 1] range
+        normalized = max(0.0, min(1.0, normalized))
+        
+        # Convert to bin index
+        bin_idx = int(normalized * self.feature_bins)
+        
+        # Ensure bin index is within valid range
+        bin_idx = max(0, min(self.feature_bins - 1, bin_idx))
+        
+        return bin_idx
+
+    def _calculate_diversity_bin(self, avg_distance: float) -> int:
+        """
+        Calculate the bin index for a given diversity value using adaptive binning.
+        
+        Args:
+            avg_distance: The average edit distance to other programs
+            
+        Returns:
+            Bin index in range [0, self.feature_bins - 1]
+        """
+        if len(self.programs) < 2:
+            # Cold start: use fixed range binning
+            # Assume reasonable range of 0-10000 for edit distance
+            max_distance = 10000
+            min_distance = 0
+        else:
+            # For diversity, we could calculate the actual range, but edit distance
+            # computation is expensive. Use a reasonable fixed range instead.
+            # Edit distances typically range from 0 to several thousand
+            max_distance = 5000
+            min_distance = 0
+        
+        # Normalize distance to [0, 1] range
+        if max_distance > min_distance:
+            normalized = (avg_distance - min_distance) / (max_distance - min_distance)
+        else:
+            normalized = 0.0
+        
+        # Clamp to [0, 1] range
+        normalized = max(0.0, min(1.0, normalized))
+        
+        # Convert to bin index
+        bin_idx = int(normalized * self.feature_bins)
+        
+        # Ensure bin index is within valid range
+        bin_idx = max(0, min(self.feature_bins - 1, bin_idx))
+        
+        return bin_idx
+
     def _feature_coords_to_key(self, coords: List[int]) -> str:
         """
         Convert feature coordinates to a string key