changes to LIPSAlgorithm.kt

Author: francastagna

core/src/main/kotlin/org/evomaster/core/search/algorithms/LIPSAlgorithm.kt

@@ -17,9 +17,38 @@ import org.evomaster.core.search.algorithms.wts.WtsEvalIndividual
 class LIPSAlgorithm<T> : AbstractGeneticAlgorithm<T>() where T : Individual {
 
     private var currentTarget: Int? = null
+    private val budgetLeftPerTarget: MutableMap<Int, Int> = mutableMapOf()
 
     override fun getType(): EMConfig.Algorithm = EMConfig.Algorithm.LIPS
 
+    override fun initPopulation() {
+        population.clear()
+
+        // 1) Generate i
+        val i = sampleSuite()
+
+        // 2) Compute uncovered 
+        val uncovered = archive.notCoveredTargets()
+        if (uncovered.isEmpty()) {
+            return
+        }
+
+        // 3) Select current target b
+        val target = uncovered.last()
+        currentTarget = target
+        frozenTargets = setOf(target)
+
+        // 4) initialize per-target budget
+        val perTarget = calculatePerTargetBudget(uncovered.size)
+        budgetLeftPerTarget.putIfAbsent(target, perTarget)
+
+        // 5) P <- RandomPopulation(ps-1) ∪ {i}
+        population.add(i)
+        while (population.size < config.populationSize) {
+            population.add(sampleSuite())
+        }
+    }
+
     override fun searchOnce() {
         beginGeneration()
 
@@ -36,16 +65,20 @@ class LIPSAlgorithm<T> : AbstractGeneticAlgorithm<T>() where T : Individual {
         }
 
         // Focus scoring on the single selected target
-        frozenTargets = setOf(currentTarget!!)
-
-        // Ensure population exists
-        if (population.isEmpty()) {
-            initPopulation()
-        }
+        frozenTargets = setOf(currentTarget)
 
         val n = config.populationSize
         val nextPop: MutableList<WtsEvalIndividual<T>> = formTheNextPopulation(population)
 
+        // record budget usage for this generation
+        val startActions = time.evaluatedActions
+        val startSeconds = time.getElapsedSeconds()
+        
+        val t = currentTarget!!
+        val targetBudgetLeft = budgetLeftPerTarget.getOrPut(t) {
+            calculatePerTargetBudget(uncovered.size)
+        }
+
         while (nextPop.size < n) {
             beginStep()
 
@@ -69,8 +102,14 @@ class LIPSAlgorithm<T> : AbstractGeneticAlgorithm<T>() where T : Individual {
             val a = if (score(o1) >= score(o2)) o1 else o2
             nextPop.add(a)
 
-            // Stop if time is up
-            if (!time.shouldContinueSearch()) {
+            // Stop if global budget or target budget is up
+            val usedForTarget = when (config.stoppingCriterion) {
+                EMConfig.StoppingCriterion.ACTION_EVALUATIONS -> time.evaluatedActions - startActions
+                EMConfig.StoppingCriterion.TIME -> time.getElapsedSeconds() - startSeconds
+                else -> 0
+            }
+            
+            if (!time.shouldContinueSearch() || usedForTarget >= targetBudgetLeft) {
                 endStep()
                 break
             }
@@ -80,14 +119,40 @@ class LIPSAlgorithm<T> : AbstractGeneticAlgorithm<T>() where T : Individual {
         population.clear()
         population.addAll(nextPop)
 
-        // If target got covered (score 1 for any in pop), refresh target next time
+        // Update budget usage for this target
+        currentTarget?.let { target ->
+            val usedForTarget = when (config.stoppingCriterion) {
+                EMConfig.StoppingCriterion.ACTION_EVALUATIONS -> time.evaluatedActions - startActions
+                EMConfig.StoppingCriterion.TIME -> time.getElapsedSeconds() - startSeconds
+                else -> 0
+            }
+            budgetLeftPerTarget[target] = (budgetLeftPerTarget[target] ?: 0) - usedForTarget
+        }
+
+        // Check if target is covered or out of budget
         val coveredNow = population.any { score(it) >= 1.0 }
-        if (coveredNow) {
+        val outOfBudget = currentTarget?.let { (budgetLeftPerTarget[it] ?: 1) <= 0 } ?: false
+        
+        if (coveredNow || outOfBudget) {
             currentTarget = null
         }
 
         endGeneration()
     }
+
+    /**
+     * Calculate per-target budget based on the current stopping criterion.
+     * Returns the fair share: total budget divided by number of uncovered targets.
+     */
+    private fun calculatePerTargetBudget(uncoveredSize: Int): Int {
+        return when (config.stoppingCriterion) {
+            EMConfig.StoppingCriterion.ACTION_EVALUATIONS -> 
+                config.maxEvaluations / uncoveredSize
+            EMConfig.StoppingCriterion.TIME -> 
+                config.timeLimitInSeconds() / uncoveredSize
+            else -> Int.MAX_VALUE
+        }
+    }
 }