world.java

遗传算法源代码,实现了选择操作、交叉操作和变异操作

/*--- formatted by Jindent 2.1, (www.c-lab.de/~jindent) ---*/

/**
 * World
 *
 * location: net.openai.ai.ga.world.World
 *
 */
package net.openai.ai.ga.world;

import net.openai.ai.ga.environment.*;
import net.openai.ai.ga.population.*;
import net.openai.ai.ga.selection.*;

/**
 * World contains all the information necessary to simulate a complete
 * genetic algorithm implementation. This includes:
 * <ul>
 *   <li>An environment (the problem to be solved)
 *   <li>A population (possible solutions to solve the problem)
 *   <li>Parent selection algorithm (ways to choose parents to create new
 *       solutions to solve the problem)
 *   <li>Mutation selection algorithm (ways to choose members of the
 *       population to mutate
 *   <li>Survival selection algorithm (ways to choose who will survive into
 *       the next generation
 * </ul>
 * <p>One iteration performs the following operations:
 * <ul>
 *   <li>Mature the population (increase its age)
 *   <li>Adjust the environment to fit its population
 *   <li>Evaluate the population
 *   <li>Create new offspring
 *   <li>Mutate the population
 *   <li>Trim the population
 * </ul>
 * @author	Jared Grubb
 * @version	%I%, %G%
 * @since	JDK1.3
 */
public class World implements java.io.Serializable {

    /**
     * The environment that the population must evaluate against
     */
    private Environment		    environment;

    /**
     * The name of this World object. Used in GeneticAlgorithm operations
     */
    private String		    name;

    /**
     * The population of this world
     */
    private Population		    population;

    /**
     * The parent selection algorithm by which new cells are created.
     * This occurs before mutation and before survival selection.
     */
    private ArraySelectionAlgorithm parentSelection;

    /**
     * The mutation selection algorithm by which cells in the population
     * are selected to mutate. This occurs after parent selection (and may
     * therefore include new offspring) but before survival selection.
     */
    private SelectionAlgorithm      mutationSelection;

    /**
     * The survival selection algorithm by which the population to survive is
     * chosen at the end of an iteration. It occurs after parent selection and
     * mutation.
     */
    private SelectionAlgorithm      survivalSelection;

    /**
     * The number of generations this world has been iterated through.
     */
    private int			    generation;

    /**
     * Reset generation count and create an empty <code>Population</code> and no
     * selection algorithms. Gives the world a name.
     *
     * @param name		a <code>String</code> for the name of this World
     */
    public World(String name) {
	this(name, new Population());
    }

    /**
     * Reset generation count, use the specified <code>Population</code>, and
     * initialize no selection algorithms.
     *
     * @param name		a <code>String</code> for the name of this World
     * @param initialPopulation	the inital <code>Population</code> for this World
     */
    public World(String name, Population initialPopulation) {
        this(name, initialPopulation, null, null, null);
    }

    /**
     * Reset generation count and create an empty population and specified
     * selection algorithms. Gives the world a name. Assign
     *
     * @param name a <code>String</code> for the name of this World
     * @param parentSelection an <code>ArraySelectionAlgorithm</code>
     *          to be used for parent selection.
     * @param mutationSelection a <code>SelectionAlgorithm</code>
     *          to be used for mutation selection.
     * @param survivalSelection a <code>SelectionAlgorithm</code>
     *          to be used for survival selection.
     */
    public World(String name, ArraySelectionAlgorithm parentSelection,
    			      SelectionAlgorithm mutationSelection,
    			      SelectionAlgorithm survivalSelection) {
	this(name, new Population(), parentSelection, mutationSelection,
	        survivalSelection);
    }

    /**
     * Reset generation count and create an empty population and specified
     * selection algorithms. Gives the world a name. Assign
     *
     * @param name a <code>String</code> for the name of this World
     * @param initialPopulation	the inital <code>Population</code> for this World
     * @param parentSelection an <code>ArraySelectionAlgorithm</code>
     *          to be used for parent selection.
     * @param mutationSelection a <code>SelectionAlgorithm</code>
     *          to be used for mutation selection.
     * @param survivalSelection a <code>SelectionAlgorithm</code>
     *          to be used for survival selection.
     */
    public World(String name, Population initialPopulation,
                              ArraySelectionAlgorithm parentSelection,
    			      SelectionAlgorithm mutationSelection,
    			      SelectionAlgorithm survivalSelection) {
        this.generation = 0;
        this.population = initialPopulation;
	this.parentSelection = parentSelection;
	this.mutationSelection= mutationSelection;
	this.survivalSelection= survivalSelection;
    }

    /**
     * Returns the name of this World.
     *
     * @return	a <code>String</code> containing the name of this World
     */
    public String getName() {
	return this.name;
    }

    /**
     * Returns a string showing the current status of this World. Returns
     * the name of the World followed by the String returned by the
     * Population's toString().
     *
     * @return	a <code>String</code> showing the status of this World
     */
    public String toString() {
	return this.getName() + ":" + this.population;
    }

    /**
     * Returns the Environment assigned to this World.
     *
     * @return	the <code>Environment</code> assigned to this World
     */
    public Environment getEnvironment() {
	return this.environment;
    }

    /**
     * Sets the Environment used in this World.
     *
     * @param newEnvironment the <code>Environment</code> to use in this World
     */
    public void setEnvironment(Environment newEnvironment) {
	this.environment = newEnvironment;
    }

    /**
     * Returns the Population assigned to this World.
     *
     * @return	the <code>Population</code> assigned to this World
     */
    public Population getPopulation() {
	return this.population;
    }

    /**
     * Sets the Population used in this World.
     *
     * @param newPopulation the <code>Population</code> to use in this World
     */
    public void setPopulation(Population newPopulation) {
	this.population = newPopulation;
    }

    /**
     * Iterates this World through one generation. Does the following items:
     * <ul>
     *   <li>Calls the environment's reactToPopulation method
     *   <li>Matures the population
     *   <li>Evaluates the population
     *   <li>Creates new offspring
     *   <li>Mutates the population
     *   <li>Trims the population
     * </ul>
     */
    public void iterate() {
	this.generation++;
	this.environment.reactToPopulation(this.population);
	this.maturePopulation();
	this.evaluatePopulation();
	this.createOffspring();
	this.mutatePopulation();
	this.trimPopulation();
    }

    /**
     * Calls the Population's mature method.
     */
    private void maturePopulation() {
	this.population.mature();
    }

    /**
     * Calls the Population's evaluate method.
     */
    private void evaluatePopulation() {
	this.population.evaluate(environment);
    }

    /**
     * Subjects the population to the parent selection algorithm and passes the
     * returned PopulationArray to the Population's <code>combine()</code>
     * method.
     */
    private void createOffspring() {
	PopulationArray parents =
	    this.parentSelection.selectFromPopulation(this.population);

	this.population.combine(parents);
    }

    /**
     * Subjects the population to the mutation selection algorithm and passes
     * the returned Population to the Population's <code>mutate()</code>
     * method.
     */
    private void mutatePopulation() {
	Population mutants =
	    this.mutationSelection.selectFromPopulation(this.population);

	this.population.mutate(mutants);
    }

    /**
     * Subjects the population to the survival selection algorithm and sets the
     * population to equal the Population returned.
     */
    private void trimPopulation() {
	Population oldPop = new Population(this.population);
	this.population.removeAllCellsBut(
		this.survivalSelection.selectFromPopulation(this.population));
	oldPop.removeCells(this.population);
	Population.condemnPopulation(oldPop);
    }

    /**
     * Sets the parent selection algorithm to the given algorithm. This
     * algorithm is used to determine the groups of cells that will be used
     * to create offspring.
     *
     * @param parentSelection a <code>ArraySelectionAlgorithm</code> to set to
     */
    public void setParentSelectionAlgorithm(
    		ArraySelectionAlgorithm parentSelection) {
	this.parentSelection = parentSelection;
    }

    /**
     * Returns the current parent selection algorithm.
     *
     * @return the parent-selection <code>ArraySelectionAlgorithm</code>
     */
    public ArraySelectionAlgorithm getParentSelectionAlgorithm() {
	return this.parentSelection;
    }

    /**
     * Sets the mutation selection algorithm to the given algorithm. This
     * algorithm is used to determine the cells that will subjected to
     * mutation.
     *
     * @param mutationSelection a <code>SelectionAlgorithm</code> to set to
     */
    public void setMutationSelectionAlgorithm(
    		SelectionAlgorithm mutationSelection) {
	this.mutationSelection = mutationSelection;
    }

    /**
     * Returns the current mutation selection algorithm. This algorithm is
     * used to determine the cells that will subjected to mutation.
     *
     * @return the mutation-selection <code>SelectionAlgorithm</code>
     */
    public SelectionAlgorithm getMutationSelectionAlgorithm() {
	return this.mutationSelection;
    }

    /**
     * Sets the survival selection algorithm to the given algorithm. This
     * algorithm is used to determine the cells that will survive into
     * the next generation.
     *
     * @param survivalSelection a <code>SelectionAlgorithm</code> to set to
     */
    public void setSurvivalSelectionAlgorithm(
    		SelectionAlgorithm survivalSelection) {
	this.survivalSelection = survivalSelection;
    }

    /**
     * Returns the current survival selection algorithm. This algorithm is
     * used to determine the cells that will survive into the next generation.
     *
     * @return the mutation-selection <code>SelectionAlgorithm</code>
     */
    public SelectionAlgorithm getSurvivalSelectionAlgorithm() {
	return this.survivalSelection;
    }
}



/*--- formatting done in "Sun Java Convention" style on 12-28-2000 ---*/