source: java/ecj/cecj/eval/TournamentCoevolutionaryEvaluator.java @ 28

package cecj.eval;

import cecj.interaction.InteractionResult;
import cecj.problems.SymmetricCompetitionProblem;
import ec.EvolutionState;
import ec.Individual;
import ec.simple.SimpleFitness;
import ec.util.Parameter;

/**
 * Single elimination tournament competitive evaluator. It is different from the other
 * coevolutionary evaluators because interactions between individuals must be simulated in strict
 * order. It depends on the outcome of previous interaction if the individual can compete further.
 * 
 * Assumes that individuals use <code>SimpleFitness</code>. The fitness assigned by this method is
 * equal to the height of the tournament subtree that particular individual has traversed - the
 * number of games won. If a series of tournaments is organized (i.e. <code>repeats</code> parameter
 * is greater than 1), the fitness is summed over all the tournaments.
 * 
 * This evaluator can be used if problem being solved implements
 * <code>SymmetricCompetitionProblem</code> interface.
 * 
 * It cannot employ any other mechanisms like archiving or fitness sharing because the interactions
 * scheme is very different and hard to generalize.
 * 
 * @author Marcin Szubert
 * 
 */
public class TournamentCoevolutionaryEvaluator extends CoevolutionaryEvaluator {

        private static final String P_REPEATS = "repeats";

        /**
         * Specifies how many times the tournament should be repeated during single evaluation process.
         * More repeats can reduce the noise of this evaluation scheme.
         */
        private int tournamentRepeats;

        private SymmetricCompetitionProblem problem;

        /**
         * Represents competing individuals.
         */
        private Individual[] competitors;

        /**
         * Number of competitors - size of the particular subpopulation.
         */
        private int numCompetitors;

        /**
         * Points gathered during the course of competition.
         */
        private int[] points;

        /**
         * An array used as a tournament tree representation. It stores indices of competing
         * individuals. Neighbouring indices copmete with each other in certain round.
         */
        private int[] competition;

        /**
         * Stores active competitors ready to be divided into pairs.
         */
        private int[] activeCompetitors;

        /**
         * Indicates if particular competitor is still in game.
         */
        private boolean[] active;

        @Override
        public void setup(final EvolutionState state, final Parameter base) {
                super.setup(state, base);

                if (!(p_problem instanceof SymmetricCompetitionProblem)) {
                        state.output.fatal("Tournament evaluator can be used only with symmetric problems");
                } else {
                        problem = (SymmetricCompetitionProblem) p_problem;
                }

                Parameter repeatsParameter = base.push(P_REPEATS);
                tournamentRepeats = state.parameters.getIntWithDefault(repeatsParameter, null, 1);
                if (tournamentRepeats <= 0) {
                        state.output.fatal("Tournament repeats parameter can not be negative.",
                                repeatsParameter);
                }
        }

        @Override
        public void evaluatePopulation(EvolutionState state) {
                for (int subpop = 0; subpop < numSubpopulations; subpop++) {
                        prepareTournament(state, subpop);
                        for (int r = 0; r < tournamentRepeats; r++) {
                                makeTournament(state);
                        }
                        assignFitness(state);
                }
        }

        /**
         * Initializes structures used in the tournament series.
         * 
         * @param state
         * @param subpop
         */
        private void prepareTournament(EvolutionState state, int subpop) {
                competitors = state.population.subpops[subpop].individuals;
                numCompetitors = competitors.length;

                points = new int[numCompetitors];
                active = new boolean[numCompetitors];
                competition = new int[numCompetitors];
                activeCompetitors = new int[numCompetitors];
        }

        /**
         * Plays a single tournament between earlier selected competitors from particular subpopulation.
         * Each tournament consists of a sequence of rounds. In each round number of active competitors
         * is reduced by half according to the results of their games (approximately - if at the start
         * of the round number of players is odd, one player is given a "bye" and advances to the next
         * round directly). At the beginning of each round there is a drawing which assigns competitors
         * in pairs.
         * 
         * @param state
         */
        private void makeTournament(EvolutionState state) {
                int numActiveCompetitors;
                for (int c = 0; c < numCompetitors; c++) {
                        active[c] = true;
                }

                while ((numActiveCompetitors = findActiveCompetitors()) > 1) {
                        shuffleCompetitors(state, numActiveCompetitors);
                        playTournamentRound(state, numActiveCompetitors);
                }
        }

        /**
         * Assign fitness value to each competing individual according to overall points which it has
         * gathered during the series of tournaments.
         * 
         * @param state
         */
        private void assignFitness(EvolutionState state) {
                for (int c = 0; c < numCompetitors; c++) {
                        Individual competitor = competitors[c];
                        ((SimpleFitness) competitor.fitness).setFitness(state, points[c], false);
                }
        }

        /**
         * Finds still active competitors according to <code>active</code> array. Found competitor
         * indices are stored in <code>activeCompetitors</code> array and their number is returned.
         * 
         * @return number of still active competitors
         */
        private int findActiveCompetitors() {
                int competitors = 0;
                for (int c = 0; c < numCompetitors; c++) {
                        if (active[c]) {
                                activeCompetitors[competitors++] = c;
                        }
                }
                return competitors;
        }

        /**
         * Randomly shuffles competitors indices taken from <
         * 
         * @param state
         * @param source
         * @param target
         * @param count
         */
        private void shuffleCompetitors(EvolutionState state, int count) {
                int left = count;
                for (int i = 0; i < count; i++) {
                        int rand = state.random[0].nextInt(left);
                        competition[i] = activeCompetitors[rand];
                        activeCompetitors[rand] = activeCompetitors[--left];
                }
        }

        /**
         * Arranges a competition between neighbours in <code>competition</code> array.
         * 
         * @param state
         * @param numCompetitors
         */
        private void playTournamentRound(EvolutionState state, int numCompetitors) {
                for (int i = 0; i + 1 < numCompetitors; i += 2) {
                        Individual c1 = competitors[competition[i]];
                        Individual c2 = competitors[competition[i + 1]];

                        // TODO: consider if it is needed to call compete method twice
                        // maybe it should use internal individual's fitness or return both results at once?
                        InteractionResult score1 = problem.compete(state, c1, c2).first;
                        InteractionResult score2 = problem.compete(state, c2, c1).first;

                        if (score1.betterThan(score2)) {
                                points[competition[i]]++;
                                active[competition[i + 1]] = false;
                        } else {
                                points[competition[i + 1]]++;
                                active[competition[i]] = false;
                        }
                }

                // TODO: in case of odd number of competitors, should the one given a "bye" achieve a point
                // in this round?
                if (numCompetitors % 2 != 0) {
                        points[competition[numCompetitors - 1]]++;
                }
        }
}