/*--- formatted by Jindent 2.1, (www.c-lab.de/~jindent) ---*//** * ArraySelectTournament Class * * location: net.openai.ai.ga.selection.common.ArraySelectTournament * */package net.openai.ai.ga.selection.common;import net.openai.ai.ga.population.*;import net.openai.ai.ga.selection.*;/** * <code>ArraySelectTournament</code> is a method by which <code> * Population</code> members are created and chosen using a tournament on a * <code>Population</code>. This algorithm is used for the selection of * parents for recombination (reproduction). * * @author	Jared Grubb * @version	%I%, %G% * @since	JDK1.3 */public class ArraySelectTournament implements ArraySelectionAlgorithm {    private SelectionAlgorithm[] groups;    private Population basePopulation;    private PopulationArray basePopulationArray;    private int goal;    /**     * Creates a new <code>ArraySelectTournament</code> that creates the     * specified number of parent sets by choosing a random parent for each     * parent slot according to each specified selection algorithm. Equilivant to     * <code>ArraySelectTournament(groupPerParent,goal,new Population())</code>.     * This creates populations based on the default <code>Population</code>     * type and collection.     *     * @param groupPerParent the <code>SelectionAlgorithm[]</code> that     *     represents a selection algorithm for each parental slot     * @param goal the number of parent sets to create     */    public ArraySelectTournament(SelectionAlgorithm[] groupPerParent, int goal)    {        this(groupPerParent,goal,new Population(),new PopulationArray());    }    /**     * Creates a new <code>ArraySelectTournament</code> that creates the     * specified number of parent sets by choosing a random parent for each     * parent slot according to each specified selection algorithm and adds     * these into the specified base population. Normally, the base population     * will be an empty population using a certain collection type.     * Equilivant to <code>ArraySelectTournament(groupPerParent, goal,     * basePopulation, new PopulationArray())</code>.     *     * @param groupPerParent the <code>SelectionAlgorithm[]</code> that     *     represents a selection algorithm for each parental slot     * @param goal the number of parent sets to create     * @param basePopulation the <code>Population</code> that each parent set     *     will be added into     */    public ArraySelectTournament(SelectionAlgorithm[] groupPerParent, int goal,                                 Population basePopulation) {        this(groupPerParent,goal,basePopulation,new PopulationArray());    }    /**     * Creates a new <code>ArraySelectTournament</code> that creates the     * specified number of parent sets by choosing a random parent for each     * parent slot according to each specified selection algorithm and adds     * these into the specified base population, which are in turn added into     * a clone of the base population array. Normally, the base population     * and base population array will be empty and implement certain collection     * types.     *     * @param groupPerParent the <code>SelectionAlgorithm[]</code> that     *     represents a selection algorithm for each parental slot     * @param goal the number of parent sets to create     * @param basePopulation the <code>Population</code> that each parent set     *     will be added into     * @param basePopulationArray the <code>PopulationArray</code> that will     *     will be used to hold the parent sets     */    public ArraySelectTournament(SelectionAlgorithm[] groupPerParent, int goal,             Population basePopulation, PopulationArray basePopulationArray) {        this.groups = groupPerParent;        this.goal = goal;        this.basePopulation = basePopulation;        this.basePopulationArray = basePopulationArray;    }    /**     * Creates a <code>PopulationArray</code> according to a tournament. The     * base population array is cloned. A parent set (a <code>Population</code>)     * is created first by cloning the base population specified in the     * constructor. Then, a member is chosen at random from each of the     * selection algorithms specified in the constructor. Each selection     * algorithm is queried only once and the results are used for every parent     * set.     *     * <p>For example, suppose the selection algorithms returned the following     * populations: {1,2,3},{3,5,7}, and {5,6,7,8,9,10}. The base population     * is the default, an empty <code>new Population()</code>. Then the     * following is a possible output for a goal of 5 parent sets:     * <ul>     *   <li>{1,5,10}     *   <li>{2,7,9}     *   <li>{3,3,5}     *   <li>{3,7,5}     *   <li>{3,7,5}     * </ul>     *     * @param pop  the <code>Population</code> to choose from     * @return a <code>PopulationArray</code> derived from the passed     * 		<code>Population</code>     *     */    public PopulationArray selectFromPopulation(Population pop) {        PopulationArray toReturn = new PopulationArray(this.basePopulationArray);        Population[] pops = new Population[groups.length];        Population working;        for(int i=0; i<this.groups.length;i++) {            pops[i] = groups[i].selectFromPopulation(pop);        }        for(int j=0; j<this.goal; j++) {            working = new Population(this.basePopulation);            for(int i=0; i<this.groups.length; i++) {                try {                   working.addCell(pops[i].getCell(                      (int)(Math.random() * pops[i].getSize())));                } catch (IndexOutOfBoundsException e) {                   // Ignore empty populations                }            }            toReturn.addPopulation(working);        }        return toReturn;    }}/*--- formatting done in "Sun Java Convention" style on 12-28-2000 ---*/