praktikum-holons/src/algorithms/geneticAlgorithm/Components/Selections/TournamentProportionalSelection.java

package algorithms.geneticAlgorithm.Components.Selections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

import algorithms.geneticAlgorithm.Components.GAIndividual;
import algorithms.geneticAlgorithm.Components.GASelectionStrategy;

public class TournamentProportionalSelection<I extends GAIndividual> implements GASelectionStrategy<I>{

	public class Range{
		
		public double min;
		public double max;
		public Range(double min, double max){
			this.min = min;
			this.max = max;
		}
	}
	
	private ArrayList<I> currentPop;
	public int tournamentSize;
	private Random rng; 
	private ArrayList<Range> tournamentWheel;
	public ArrayList<I> competitors;
	//public double selectProb;
	private double maxRange;
	
	
	public TournamentProportionalSelection(){
		currentPop = new ArrayList<I>();
		tournamentSize = 1;
		rng = new Random();
	}
	
	public TournamentProportionalSelection(int tSize){
		currentPop = new ArrayList<I>();
		rng = new Random();
		tournamentSize = tSize;
	}
	
	@Override
	public void setCurrentPopulation(ArrayList<I> population) {
		currentPop.clear();
		currentPop.addAll(population);
	}
	
	public void setTournamentSize(int size){
		if(size <= 0){
			tournamentSize = 1;
		}else{
			tournamentSize = size;
		}
	}

	@Override
	public ArrayList<I> selectIndividuals() {
		ArrayList<I> parents = new ArrayList<I>();
		parents.add(selectSingleIndividual());
		parents.add(selectSingleIndividual());
		return parents;
	}
	
	public I selectSingleIndividual(){
		tournamentSelection();
		if(competitors.get(competitors.size()-1).getFittness() <= 0){
			normalizedWheelInit();
		}else{
			proportionalWheelInit();
		}
		//initWheel();
		double index = rng.nextDouble() * maxRange;
		for(int i = 0; i < tournamentWheel.size(); i++){
			if(index >= tournamentWheel.get(i).min && index <= tournamentWheel.get(i).max){
				return competitors.get(i);
			}
		}
		return competitors.get(rng.nextInt(competitors.size()));
	}
	
	public void tournamentSelection(){
		competitors = new ArrayList<I>();
		Collections.shuffle(currentPop);
		for(int i = 0; i < tournamentSize; i++){
			I candidate = currentPop.get(i);
			int size = competitors.size();
			for(int j = 0; j <= size; j++){
				if(j != size){
					if(competitors.get(j).getFittness() < candidate.getFittness()){
						competitors.add(j, candidate);
						break;
					}
				}else{
					competitors.add(candidate);
				}
			}
		}		
	}
	
	public I chooseCandidate(){
		int index = rng.nextInt(currentPop.size());
		I candidate = currentPop.get(index);
		return candidate;
	}
	
	public void initWheel(){
		tournamentWheel = new ArrayList<Range>();
		maxRange = 0;
		double smallestFittness = competitors.get(competitors.size()).getFittness();
		double biggestFittness = competitors.get(0).getFittness();
		double distance = biggestFittness - smallestFittness;
		double fittnessSum = 0;
		for(GAIndividual i : competitors){
			fittnessSum += i.getFittness();
		}
		if(smallestFittness <= 0){
			smallestFittness = 0 - smallestFittness;
		}
		fittnessSum += competitors.size() * smallestFittness;
		double avgFittness = fittnessSum / competitors.size();
		double relativeSizeFactor = 1;
		if(distance != 0){
			relativeSizeFactor = distance/avgFittness;
		}
		double addedValue = (fittnessSum / relativeSizeFactor) * (1/competitors.size());
		fittnessSum += competitors.size() * addedValue;
		
		for(GAIndividual i : competitors){
			
			Range range = new Range(maxRange, maxRange + i.getFittness() + smallestFittness + addedValue);
			tournamentWheel.add(range);
			maxRange += maxRange + i.getFittness() + smallestFittness + addedValue;
			i.addLogEntry("Selection Prob: " + 
					(fittnessSum/(i.getFittness()+smallestFittness+addedValue))*100 + "%");
		}
	}
	
	public void normalizedWheelInit(){
		tournamentWheel = new ArrayList<Range>();
		maxRange = 0;
		double smallestFittness = competitors.get(competitors.size()-1).getFittness();
		double biggestFittness = competitors.get(0).getFittness();
		//System.out.println("smallest: " + smallestFittness);
		//System.out.println("biggest: " + biggestFittness);
		double distance = biggestFittness - smallestFittness;
		//System.out.println("distance: " + distance);
		smallestFittness = Math.abs(smallestFittness);
		biggestFittness = Math.abs(smallestFittness);

		double fittnessSum = 0;
		for(GAIndividual i : competitors){
			fittnessSum += i.getFittness();
		}
		fittnessSum += (smallestFittness)*competitors.size();
		double relativeMaxSizeFactor = 1;
		double relativeMinSizeFactor = 1;
		
		if(distance > 0){
			relativeMaxSizeFactor = distance/biggestFittness;
			if(smallestFittness > 0){
				relativeMinSizeFactor = distance/smallestFittness;
			}
		}
		
		double avgRelativeSizeFactor = relativeMaxSizeFactor + relativeMinSizeFactor;
		avgRelativeSizeFactor = avgRelativeSizeFactor/2;
		double addedValue = fittnessSum / avgRelativeSizeFactor;
		fittnessSum += addedValue;
		addedValue = addedValue/competitors.size();
		maxRange = 0;
		for(GAIndividual i : competitors){
			double rangeEnd = maxRange + i.getFittness() + smallestFittness + addedValue;
			Range range = new Range(maxRange, rangeEnd);
			i.addLogEntry("Selection Prob : " + ((rangeEnd - maxRange)/fittnessSum)*100
					+ "%");
			maxRange = rangeEnd;	
		}
		
	}
	
	public void proportionalWheelInit(){
		tournamentWheel = new ArrayList<Range>();
		maxRange = 0;
		for(GAIndividual i : competitors){
			
			Range range = new Range(maxRange, maxRange + i.getFittness());
			maxRange += maxRange + i.getFittness();
			i.addLogEntry("proportional Selection");
		}
	}

}