strictpermutation.java

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

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

/**
 * StrictPermutation
 * 
 * location: net.openai.ai.ga.cell.encoding.StrictPermutation
 * 
 */
package net.openai.ai.ga.cell.encoding;

/**
 * The <code>StrictPermutation</code> class stores a permutation of values from
 * 0 to (length-1). All values are represented, however it is their order
 * that is of interest. This class supports cross-over and mutation.
 * 
 * the maximum for the list in
 * @author	Jared Grubb
 * @version	%I%, %G%
 * @since	JDK1.3
 */
public class StrictPermutation {

    /**
     * The list of values
     */
    private int[]  valList;

    /**
     * The name of this permutation
     */
    private String name;

    /**
     * Creates a new <code>StrictPermutation</code> with the specified length
     * and given name.
     * 
     * @param name	a <code>String</code> representing the string's name
     * @param length	the number of elements in this list
     */
    public StrictPermutation(String name, int length) {
	setLength(length);
	setListLoosely(null);
    }

    /**
     * Creates a new <code>StrictPermutation</code> initialized with the
     * specified capacity and starting with the values in the passed integer
     * array so far as is possible using <code>setListLoosely</code>.
     * 
     * @param name	a <code>String</code> representing the string's name
     * @param capacity	the number of elements in this list
     * @param value	the initial value for the binary string
     */
    public StrictPermutation(String name, int length, int[] vals) {
	setLength(length);
	setListLoosely(vals);
    }

    /**
     * Creates and returns a clone of the given <code>StrictPermutation</code>.
     * Throws <code>NullPointerException</code> when passed <code>null</code>.
     * 
     * @param toClone	the binary string to clone
     */
    public StrictPermutation(StrictPermutation toClone) {
	this(toClone.getName(), toClone.getLength(), toClone.getList());
    }

    /**
     * Returns the length of this permutation list
     * 
     * @returns the length of the permutation
     */
    public int getLength() {
	return this.valList.length;
    } 

    /**
     * Sets the length of this permutation. Destroys any previous list and
     * initializes a new one.
     * 
     * @param length	the length of the permutation
     */
    public void setLength(int size) {
	if (size < 0) {

	    // Throw exception
	} 

	this.valList = new int[size];

	for (int i = 0; i < size; i++) {
	    this.valList[i] = i;
	}
    } 

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

    /**
     * Sets the name of this permutation
     * 
     * @param name	the <code>String</code> for the new name of this list
     */
    public void setName(String name) {
	this.name = name;
    } 

    /**
     * Returns this permutation as a <code>int[]</code>.
     * 
     * @returns a <code>int[]</code> of this permutation
     */
    public int[] getList() {
	return this.valList;
    } 

    /**
     * Sets the permutation to the values in the given list.
     * 
     * @param list 	an <code>int[]</code> value to duplicate
     */
    public void setList(int[] list) {
	if (list.length != this.valList.length) {

	    // Throw exception
	    return;
	} 

	boolean[] check = new boolean[this.valList.length];

	for (int i = 0; i < this.valList.length; i++) {
	    check[i] = false;
	}

	for (int i = 0; i < this.valList.length; i++) {
	    if (check[list[i]] == true) {

		// Throw exception??
		return;
	    } 

	    this.valList[i] = list[i];
	    check[list[i]] = true;
	} 
    } 

    /**
     * Sets the permutation to the values in the given list when possible.
     * Calls setListLoosely(list, 0);
     * 
     * @param list 	an <code>int[]</code> value to try to duplicate
     */
    public void setListLoosely(int[] list) {
	setListLoosely(list, 0);
    } 

    /**
     * Sets the permutation to the values in the given list when possible
     * starting from a given position. All elements before this position are
     * left alone. If a duplicate is found, it is skipped and not added a
     * second time. If not all values have been added into the list, then they
     * are added sequentially to fill the list. When (start<0) or (start>length)
     * an exception is thrown.
     * 
     * @param list 	an <code>int[]</code> value to try to duplicate
     * @param start the position to start from
     */
    public void setListLoosely(int[] list, int start) {
	if (start < 0 || start > this.valList.length) {

	    // Throw exception
	    return;
	} 

	boolean[] check = new boolean[this.valList.length];

	for (int i = 0; i < this.valList.length; i++) {
	    check[i] = false;
	}

	for (int i = 0; i < start; i++) {
	    check[this.valList[i]] = true;
	}

	// Try to copy this list
	int j = start;

	if (list != null) {
	    for (int i = 0; i < list.length; i++) {

		// Make sure it's a good value first
		if (list[i] < 0 || list[i] >= this.valList.length) {
		    continue;

		    // Add it if not already done
		} 

		if (check[list[i]] == false) {
		    this.valList[j++] = list[i];
		    check[list[i]] = true;

		    if (j > this.valList.length) {
			break;
		    } 
		} 
	    } 
	} 

	int i = 0;    // Add all the rest of the numbers

	for (; j < this.valList.length; j++) {
	    while (check[i] == true) {
		i++;
	    }

	    this.valList[j] = i;
	    check[i] = true;
	} 
    } 

    /**
     * Returns the value of a certain element in the permutation
     * 
     * @param element	the element to return
     * @returns	the value of the permutation at this point
     */
    public int getElement(int element) {
	if (element < 0 || element > this.valList.length) {

	    // Throw exception
	    return 0;
	} 

	return valList[element];
    } 

    /**
     * Returns a new <code>StrictPermutation</code> based on two other
     * permutations of the same length. A cross-over point is picked at
     * random and all elements before this point are the same as the first
     * parent's and all all other elements are added in the same order as they
     * are in the second permutation when possible. Neither parent is altered
     * during this call.
     * 
     * @param first	the first <code>StrictPermutation</code>
     * @param second the second <code>StrictPermutation</code>
     * @returns	a new <code>StrictPermutation</code>
     */
    public static StrictPermutation cross(StrictPermutation first, 
					  StrictPermutation second) {
	if (first.getLength() != second.getLength()) {

	    // Throw exception
	    return null;
	} 

	StrictPermutation n = new StrictPermutation(first);
	int		  crossover_pt = 
	    ((int) (Math.random() * (double) (first.getLength())));

	n.setListLoosely(second.getList(), crossover_pt);

	return n;
    } 

    /**
     * Mutates a given number of elements in the permutation. The mutation is
     * the exchange of two elements in the list. A non-positive argument
     * results in no change in the string.
     * 
     * @param amount the number of elements to exchange ("mutate")
     */
    public void mutate(int amount) {
	int f, s, temp;

	for (int i = 0; i < amount; i++) {
	    f = (int) ((Math.random() * (double) (this.getLength())));
	    s = (int) ((Math.random() * (double) (this.getLength())));
	    temp = this.valList[f];
	    this.valList[f] = this.valList[s];
	    this.valList[s] = temp;
	} 
    } 

    /**
     * Method declaration
     *
     *
     * @return
     *
     * @see
     */
    public String toString() {
	StringBuffer sb = new StringBuffer(String.valueOf(this.valList[0]));

	for (int i = 1; i < this.valList.length; i++) {
	    sb.append(" " + this.valList[i]);
	}

	return sb.toString();
    } 

}



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