thresholdselector.java

JGAP是一种遗传算法和遗传规划的组成部分提供了一个Java框架。它提供了基本的遗传机制

/*
 * This file is part of JGAP.
 *
 * JGAP offers a dual license model containing the LGPL as well as the MPL.
 *
 * For licensing information please see the file license.txt included with JGAP
 * or have a look at the top of class org.jgap.Chromosome which representatively
 * includes the JGAP license policy applicable for any file delivered with JGAP.
 */
package org.jgap.impl;

import java.util.*;
import org.jgap.*;

/**
 * Implementation of a NaturalSelector that ensures a certain threshold of the
 * best chromosomes are taken to the next generation.
 *
 * @author Klaus Meffert
 * @since 2.0
 */
public class ThresholdSelector
    extends NaturalSelectorExt {
  /** String containing the CVS revision. Read out via reflection!*/
  private final static String CVS_REVISION = "$Revision: 1.19 $";

  /**
   * Stores the chromosomes to be taken into account for selection
   */
  private List m_chromosomes;

  /**
   * Indicated whether the list of added chromosomes needs sorting
   */
  private boolean m_needsSorting;

  /**
   * Comparator that is only concerned about fitness values
   */
  private FitnessValueComparator m_fitnessValueComparator;

  private ThresholdSelectorConfigurable m_config
      = new ThresholdSelectorConfigurable();

  /**
   * Default constructor. Uses threshold of 30 percent.<p>
   * Attention: The configuration used is the one set with the static method
   * Genotype.setConfiguration.
   *
   * @throws InvalidConfigurationException
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public ThresholdSelector()
      throws InvalidConfigurationException {
    this(Genotype.getStaticConfiguration(), 0.3d);
  }

  /**
   * @param a_config the configuration to use
   * @param a_bestChromosomes_Percentage indicates the number of best
   * chromosomes from the population to be selected for granted. All other
   * chromosomes will be selected in a random fashion. The value must be in
   * the range from 0.0 to 1.0.
   * @throws InvalidConfigurationException
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  public ThresholdSelector(final Configuration a_config,
                           final double a_bestChromosomes_Percentage)
      throws InvalidConfigurationException {
    super(a_config);
    if (a_bestChromosomes_Percentage < 0.0000000d
        || a_bestChromosomes_Percentage > 1.0000000d) {
      throw new IllegalArgumentException("Percentage must be between 0.0"
          + " and 1.0 !");
    }
    m_config.m_bestChroms_Percentage = a_bestChromosomes_Percentage;
    m_chromosomes = new Vector();
    m_needsSorting = false;
    m_fitnessValueComparator = new FitnessValueComparator();
  }

  /**
   * Select a given number of Chromosomes from the pool that will move on
   * to the next generation population. This selection will be guided by the
   * fitness values. The chromosomes with the best fitness value win.

   * @param a_howManyToSelect the number of Chromosomes to select
   * @param a_to_pop the population the Chromosomes will be added to
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  public void selectChromosomes(final int a_howManyToSelect,
                                Population a_to_pop) {
    int canBeSelected;
    if (a_howManyToSelect > m_chromosomes.size()) {
      canBeSelected = m_chromosomes.size();
    }
    else {
      canBeSelected = a_howManyToSelect;
    }
    // Sort the collection of chromosomes previously added for evaluation.
    // Only do this if necessary.
    // -------------------------------------------------------------------
    if (m_needsSorting) {
      Collections.sort(m_chromosomes, m_fitnessValueComparator);
      m_needsSorting = false;
    }
    // Select the best chromosomes for granted
    int bestToBeSelected = (int) Math.round(canBeSelected
        * m_config.m_bestChroms_Percentage);
    for (int i = 0; i < bestToBeSelected; i++) {
      a_to_pop.addChromosome( (IChromosome) m_chromosomes.get(i));
    }
    // Fill up the rest by randomly selecting chromosomes.
    // ---------------------------------------------------
    /**@todo replace this step by adding newly to create chromosomes*/
    int missing = a_howManyToSelect - bestToBeSelected;
    RandomGenerator rn = getConfiguration().getRandomGenerator();
    int index;
    int size = m_chromosomes.size();
    for (int i = 0; i < missing; i++) {
      index = rn.nextInt(size);
      IChromosome chrom = (IChromosome) m_chromosomes.get(index);
      a_to_pop.addChromosome(chrom);
    }
  }

  /**
   * @return false as we allow to return the same chromosome multiple times
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  public boolean returnsUniqueChromosomes() {
    return false;
  }

  public void empty() {
    m_chromosomes.clear();
    m_needsSorting = false;
  }

  /**
   *
   * @param a_chromosomeToAdd Chromosome
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  protected void add(final IChromosome a_chromosomeToAdd) {
    m_chromosomes.add(a_chromosomeToAdd);
    m_needsSorting = true;
  }

  /**
   * Comparator regarding only the fitness value. Best fitness value will
   * be on first position of resulting sorted list.
   *
   * @author Klaus Meffert
   * @since 2.0
   */
  private class FitnessValueComparator
      implements Comparator {
    public FitnessValueComparator() {

    }
    public int compare(final Object a_first, final Object a_second) {
      IChromosome chrom1 = (IChromosome) a_first;
      IChromosome chrom2 = (IChromosome) a_second;
      if (getConfiguration().getFitnessEvaluator().isFitter(chrom2.
          getFitnessValue(), chrom1.getFitnessValue())) {
        return 1;
      }
      else if (getConfiguration().getFitnessEvaluator().isFitter(
          chrom1.getFitnessValue(), chrom2.getFitnessValue())) {
        return -1;
      }
      else {
        return 0;
      }
    }
  }
  class ThresholdSelectorConfigurable {
    /**
     * This percentage indicates the number of best chromosomes from the
     * population to be selected for granted. All other chromosomes will
     * be selected in a random fashion.
     */
    public double m_bestChroms_Percentage;
  }
}