trjhtr

I have this method that takes a list of my individuals (class has public field fitnessValue). I sum all fitnessValue and then draw a random value between 0 and sum of fitnessValue. In the end, I check for each individual where cumulative sum of fitnessValue passes the point I counted before and return the one which passed first.

public Individual pickRandomIndividual(List<Individual> pool) 
 Double totalScore = 0d;
 Double runningScore = 0d;
 for (Individual ind : pool) 
 totalScore += ind.fitnessValue;
 

 Double rnd = Math.random() * totalScore;

 for (Individual ind : pool) 
 if (rnd >= runningScore &&
 rnd <= runningScore + ind.fitnessValue) 
 return ind;
 
 runningScore += ind.fitnessValue;
 
 return null;
 

I want to refactor this function with Java 8 streams. Any idea how can I achieve that?

I changed it a bit, into:

Double fitnessSum = genePool.stream()
 .mapToDouble(individual -> individual.fitnessValue)
 .sum();
Double runningScore = 0d;

Double rnd = random() * fitnessSum;

for (Individual g : genePool) 
 if (rnd >= runningScore && rnd <= runningScore + g.fitnessValue) 
 return g;
 
 runningScore += g.fitnessValue;

return null;

Still, I do not know how to change cumulative sum part into a stream. Maybe entire logic is poorly implemented? I just want to draw one Individual from the list depending on how large the Individual's fitnessValue is.

You have to keep in mind that Streams are not the solution to everything. In this case for example, you need to keep track of multiple values, i.e. the current individual, and a cumulative sum (and you have to return a a value as soon as a certain condition is met). Yes, there are ways to do this with Streams, but I think in this case it is best to implement it with a simple loop like you have.

A couple of side notes:

• Use the primitive type double instead of the wrapper class.


• Declare variables as late as possible.


• Perhaps allow the user to pass a Random instance.


• 
  

  I think your implementation can be simplified by subtracting, which would then mean you only have to check for < 0, e.g.:

  
  
  

  double fitnessSum = genePool.stream()
   .mapToDouble(individual -> individual.fitnessValue)
   .sum();
  
  double remainder = Math.random() * fitnessSum;
  for (Individual gene : genePool) 
   remainder -= gene.fitnessValue;
   if (remainder <= 0.0) 
   return gene;
   
  
  return genePool.get(genePool.size() - 1);
  

  
  

There's also this variation on the classic solution to picking a random element from an Iterator while iterating only once:

Double fitnessSum = 0.0;
Individual chosen = null;
for (Individual g : genePool) 
 fitnessSum += g.fitnessValue;
 if (Math.random() * fitnessSum < g.fitnessValue) 
 chosen = g;
 

return g;

• 
  

  In the second loop, the loop where you update runningScore, there is no need to check whether rnd >= runningScore, because at the first loop iteration, it will be true by default, and at every subsequent iteration, runningScore will be equal to the runningScore of the previous iteration plus the fitnessValue of the previous individual, and if this value were greater than (or even equal to) rnd, then the loop would have already been terminated at the previous iteration. In fact, you could rewrite this loop to:

  
  
  

  for (Individual ind : pool) 
   runningScore += ind.fitnessValue;
   if (rnd <= runningScore) 
   return ind;
   
  
  

  
  
  

  That way, you only have to perform the addition once, saving performance. Of course, this assumes that fitnessValue will always be non-negative.

  
  


• 
  

  Based on how the code is supposed to work, the return null; statement after the last for loop should never be reached. Since the compiler does not know that, you could insert an assert false; before the return statement. It is also possible to use assert statements with a detail message, for example like this:

  
  
  

  assert false : "totalScore: " + totalScore;