Feature: Simulated annealing optimization

src/main/java/com/bobrust/generator/HillClimbGenerator.java

@@ -2,8 +2,8 @@
 
 import com.bobrust.util.data.AppConstants;
 
-import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
 
 class HillClimbGenerator {
 	private static State getBestRandomState(List<State> random_states) {
@@ -14,59 +14,162 @@ private static State getBestRandomState(List<State> random_states) {
 			state.shape.randomize();
 		}
 		random_states.parallelStream().forEach(State::getEnergy);
-		
+
 		float bestEnergy = 0;
 		State bestState = null;
 		for (int i = 0; i < len; i++) {
 			State state = random_states.get(i);
 			float energy = state.getEnergy();
-			
+
 			if (bestState == null || energy < bestEnergy) {
 				bestEnergy = energy;
 				bestState = state;
 			}
 		}
-		
+
 		return bestState;
 	}
-
-	public static State getHillClimb(State state, int maxAge) {
+
+	/**
+	 * Original hill climbing implementation. Kept as fallback when
+	 * {@link AppConstants#USE_SIMULATED_ANNEALING} is false.
+	 */
+	public static State getHillClimbClassic(State state, int maxAge) {
 		float minimumEnergy = state.getEnergy();
-		
+
 		// Prevent infinite recursion
 		int maxLoops = 4096;
-		
+
 		State undo = state.getCopy();
-		
+
 		// This function will minimize the energy of the input state
 		for (int i = 0; i < maxAge && (maxLoops-- > 0); i++) {
 			state.doMove(undo);
 			float energy = state.getEnergy();
-			
+
 			if (energy >= minimumEnergy) {
 				state.fromValues(undo);
 			} else {
 				minimumEnergy = energy;
 				i = -1;
 			}
 		}
-		
+
 		if (maxLoops <= 0 && AppConstants.DEBUG_GENERATOR) {
 			AppConstants.LOGGER.warn("HillClimbGenerator failed to find a better shape after {} tries", 4096);
 		}
-		
+
 		return state;
 	}
-
+
+	/**
+	 * Simulated annealing implementation that can escape local minima by
+	 * probabilistically accepting worse moves early in the search.
+	 */
+	public static State getHillClimbSA(State state, int maxAge) {
+		float currentEnergy = state.getEnergy();
+		State bestState = state.getCopy();
+		float bestEnergy = currentEnergy;
+
+		// Estimate initial temperature from sample mutations
+		float temperature = estimateTemperature(state);
+		int totalIterations = maxAge * 10;
+		float coolingRate = computeCoolingRate(temperature, maxAge);
+
+		State undo = state.getCopy();
+
+		for (int i = 0; i < totalIterations; i++) {
+			state.doMove(undo);
+			float newEnergy = state.getEnergy();
+			float delta = newEnergy - currentEnergy;
+
+			if (delta < 0) {
+				// Improvement — always accept
+				currentEnergy = newEnergy;
+				if (currentEnergy < bestEnergy) {
+					bestEnergy = currentEnergy;
+					bestState = state.getCopy();
+				}
+			} else if (temperature > 0.001f) {
+				// Worse move — accept with probability exp(-delta/T)
+				double acceptProb = Math.exp(-delta / temperature);
+				if (ThreadLocalRandom.current().nextDouble() < acceptProb) {
+					currentEnergy = newEnergy;
+				} else {
+					state.fromValues(undo);
+				}
+			} else {
+				state.fromValues(undo);
+			}
+
+			temperature *= coolingRate;
+		}
+
+		// Return the best state found during the entire SA run
+		return bestState;
+	}
+
+	/**
+	 * Dispatches to SA or classic hill climbing based on the feature flag.
+	 */
+	public static State getHillClimb(State state, int maxAge) {
+		if (AppConstants.USE_SIMULATED_ANNEALING) {
+			return getHillClimbSA(state, maxAge);
+		} else {
+			return getHillClimbClassic(state, maxAge);
+		}
+	}
+
+	/**
+	 * Estimate a good starting temperature by sampling random mutations and
+	 * measuring average energy deltas. Sets T so that roughly 60% of uphill
+	 * moves are accepted at the start.
+	 */
+	static float estimateTemperature(State state) {
+		State probe = state.getCopy();
+		State undo = probe.getCopy();
+		float totalDelta = 0;
+		int samples = 30;
+
+		for (int i = 0; i < samples; i++) {
+			float before = probe.getEnergy();
+			probe.doMove(undo);
+			float after = probe.getEnergy();
+			totalDelta += Math.abs(after - before);
+			probe.fromValues(undo); // restore
+		}
+
+		float avgDelta = totalDelta / samples;
+		// Set T so ~60% of uphill moves are accepted initially
+		// P = exp(-avgDelta / T) = 0.6 => T = -avgDelta / ln(0.6)
+		// -1/ln(0.6) ≈ 1.957, but we use avgDelta / 0.5108 which is equivalent
+		return (float) (avgDelta / 0.5108);
+	}
+
+	/**
+	 * Compute the geometric cooling rate so that temperature decays from
+	 * {@code initialTemp} to near-zero (0.001) over {@code maxAge * 10} iterations.
+	 */
+	static float computeCoolingRate(float initialTemp, int maxAge) {
+		int totalIterations = maxAge * 10;
+		float finalTemp = 0.001f;
+		if (initialTemp <= finalTemp) {
+			return 0.99f; // fallback if temperature is already tiny
+		}
+		// initialTemp * rate^totalIterations = finalTemp
+		// rate = (finalTemp / initialTemp) ^ (1 / totalIterations)
+		return (float) Math.pow(finalTemp / initialTemp, 1.0 / totalIterations);
+	}
+
 	public static State getBestHillClimbState(List<State> random_states, int age, int times) {
 		float bestEnergy = 0;
 		State bestState = null;
-		
+
 		for (int i = 0; i < times; i++) {
 			State oldState = getBestRandomState(random_states);
 			State state = getHillClimb(oldState, age);
 			float energy = state.getEnergy();
-			
+
 			if (i == 0 || bestEnergy > energy) {
 				bestEnergy = energy;
 				bestState = state.getCopy();

src/main/java/com/bobrust/generator/Model.java

@@ -56,7 +56,7 @@ private void addShape(Circle shape) {
 
 	private static final int max_random_states = 1000;
 	private static final int age = 100;
-	private static final int times = 1;
+	private static final int times = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
 
 	private List<State> randomStates;
 

src/main/java/com/bobrust/util/data/AppConstants.java

@@ -24,6 +24,9 @@ public interface AppConstants {
 	boolean DEBUG_DRAWN_COLORS = false;
 	boolean DEBUG_TIME = false;
 	int MAX_SORT_GROUP = 1000; // Max 1000 elements per sort
+
+	// When true, use simulated annealing instead of pure hill climbing for shape optimization
+	boolean USE_SIMULATED_ANNEALING = true;
 
 	// Average canvas colors. Used as default colors
 	Color CANVAS_AVERAGE = new Color(0xb3aba0);