Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.search.api.FitnessFunction.java

Here you can find all the information about the file org.dgpf.search.api.FitnessFunction.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-03-30 15:03:20
 * Original Filename: org.dgpf.search.api.FitnessFunction.java
 * Version          : 2.0.0
 * Last modification: 2006-05-08
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.dgpf.search.api;

import java.io.Serializable;

import org.sfc.math.stochastic.statistics.StatisticInfo;
import org.sfc.utils.Typesafe;

/**
 * This is the base class of all fitness functions. A fitness function
 * must itself have dynamic data, that is, no data that might change over
 * time. It must use the fitness data record (<code>FitnessData</code>) or
 * an own derived <code>FitnessData</code>-implementation for this. A
 * fitness function might be used by any count of threads in parallel, but
 * must not be synchronized. Every thread will use its own fitness record
 * containing all valueable data, so no synchronization is needed.
 *
 * @param <Genotype>    The sort of genotype used to represent individuals.
 *                      This must be a serializable type.
 * @param <FitnessDataType> The type of fitness data record this fitness
 *                          function uses.
 * @see FitnessData
 * @author Thomas Weise
 */

public abstract class FitnessFunction
                    <Genotype        extends Serializable,
                     FitnessDataType extends FitnessData<Genotype>>
  {
/**
 * The minimum count of simulations that are needed so using the median
 * makes sense.
 */

  protected static  final int     MIN_MEDIAN_THRESHOLD = 10;
/**
 * The ln subtractor for fitness computation.
 */

  private   static  final double  LN_SUB               =
                                      (MIN_MEDIAN_THRESHOLD - Math.E);
  
/**
 * This value states after how many simulation steps this function will
 * need to introspect the simulation state. If it equals <code>-1</code>,
 * no inspection is needed at all.
 * @see #get_inspection_steps()
 */

  private final long    m_inspection_steps ;
/**
 * The precision of this fitness function. This is the count of levels to
 * be used for the calculation.
 */

  private final double  m_precision ;

/**
 * Create a new fitness function.
 * @param p_inspection_steps    This value states after how many simulation
 *                              steps this function will need to introspect
 *                              the simulation state. If it equals
 *                              <code>-1</code>, no inspection is needed at
 *                              all.
 * @param p_precision   The precision of this fitness function. This is the
 *                      count of levels to be used for the calculation.
 *                      If this parameter is <= 0.0d, the full precision
 *                      available will be used.
 */

  public  FitnessFunction (final long   p_inspection_steps,
                           final double p_precision)
    {
    super();
    this.m_inspection_steps = (p_inspection_steps > 0) ?
                               p_inspection_steps      : -1;
    this.m_precision        = p_precision;
    }

/**
 * This method returns after how many simulation steps this function will
 * need to introspect the simulation state. If it returns <code>-1</code>,
 * no inspection is needed at all.
 * @return  The count of simulation steps between two introspections, or
 *          <code>-1</code> if no inspections are needed at all.
 */

  public  final long get_inspection_steps ()
    {
    return this.m_inspection_steps;
    }


/**
 * Create a new instance of the dynamic data container of this fitness
 * function. You must override this method if you aren't using default
 * <code>FitnessData</code> instances.
 * @return A new instance of the dynamic data container of this fitness
 *         function
 */

  protected  FitnessDataType create_fitness_data ()
    {
    return Typesafe.cast(new FitnessData());
    }

/**
 * Perform a sanity check if there is any use in simulating this individual.
 * @param p_individual  The individual to be sanity-checked.
 * @return  <code>true</code> if and only if the individual shall be
 *          evaluated, <code>false</code> to abort evaluation of the
 *          individual because it is wack for some reason.
 */

  protected  boolean should_simulate (final Genotype p_individual)
    {
    return true;
    }

/**
 * This method is called when a simulation is about to begin. It should
 * perform any initialization needed.
 * @param p_fitness       The fitness data record to be used in this
 *                        simulation.
 * @param p_context       The context driving the simulation.
 */

  protected  void begin_simulation(
                      final FitnessDataType          p_fitness,
                      final SearchContext<Genotype>  p_context)
    {
    //
    }

/**
 * This method is called when the simulation proceeded to a step
 * <code>p_step</code>, where
 * <code>p_step % get_steps_between_inspections() == 0</code>, if
 * <code>get_steps_between_inspections() > 0</code>.
 * @param p_fitness       The fitness data record used in this simulation.
 * @param p_context       The context driving the simulation.
 * @param p_step          The current count of completed steps.
 */

  protected  void inspect(final FitnessDataType           p_fitness,
                          final SearchContext<Genotype>   p_context,
                          final long                      p_step)
    {
    //
    }


/**
 * This method is called when a simulation has come to an end.
 * You must use this method to store a fitness value into the fitness
 * record <code>p_fitness</code>. Use <code>set_fitness</code> for this.
 * @param p_fitness       The fitness data record that was used in this
 *                        simulation.
 * @param p_context       The context that has driven the simulation.
 * @see FitnessData#set_fitness(double)
 */

  protected  void end_simulation(
                      final FitnessDataType          p_fitness,
                      final SearchContext<Genotype>  p_context)
    {
    //
    }

/**
 * <p>
 * Obtain the fitness value from the statistics gathered from the fitness
 * data on all simulation runs. You can select any of the statistic
 * parameters of the info record as fitness. To obtain stable results, for
 * example, you could choose the minimum fitness value to be returned.
 * To select individuals with good average fitness, return the average.
 * To select individuals which are good most often, select the median.
 * </p><p>
 * This default implementation checks if the median is numeric. If so, it
 * will be returned. Otherwise we repeat the same procedure with the
 * minimum, the average and the maximum. If none of them is numeric, we
 * return 0.0d.
 * </p>
 *
 * @param p_info  This statistical information record is the essence of all
 *                fitness information stored in the fitness data bags
 *                filled during the simulation runs. Each simulation run
 *                will contribute to this record.
 *
 * @return  A fitness value computed from the statistic info record of
 *          the fitness data bags.
 */

  protected  double  calculate_fitness (final StatisticInfo p_info)
    {
    int     l_c;
    double  l_d;

    l_c = p_info.get_count();

    if(l_c <=  0) return 0.0d;
        
    if(l_c >= MIN_MEDIAN_THRESHOLD)
      {
      l_d = Math.log(l_c - LN_SUB);      
      l_d = (((l_d*p_info.get_median())+p_info.get_average()) / (l_d+1.0d));
      
      l_d = SearchUtils.format_positive(l_d);
      }
    else l_d = SearchUtils.format_positive(p_info.get_average());
    return l_d;
    }

/**
 * Returns a human readable name of this fitness function.
 * @return A human readable name of this fitness function.
 */

  @Override
  public  abstract  String  toString  ();
  
/**
 * <p>
 * Obtain the fitness value from the statistics gathered from the fitness
 * data on all simulation runs. You can select any of the statistic
 * parameters of the info record as fitness. To obtain stable results, for
 * example, you could choose the minimum fitness value to be returned.
 * To select individuals with good average fitness, return the average.
 * To select individuals which are good most often, select the median.
 * </p><p>
 * This default implementation checks if the median is numeric. If so, it
 * will be returned. Otherwise we repeat the same procedure with the
 * minimum, the average and the maximum. If none of them is numeric, we
 * return 0.0d.
 * </p>
 *
 * @param p_info  This statistical information record is the essence of all
 *                fitness information stored in the fitness data bags
 *                filled during the simulation runs. Each simulation run
 *                will contribute to this record.
 *
 * @return  A fitness value computed from the statistic info record of
 *          the fitness data bags.
 */

  final double  do_calculate_fitness (final StatisticInfo p_info)
    {
    double l_d, l_f;
    
    l_d = this.calculate_fitness(p_info);
    if(this.m_precision <= 0.0d) return l_d;
    
                         
    l_f = Math.exp(this.m_precision-Math.rint(Math.log(l_d)));
    return ((Math.rint(l_d*l_f))/l_f);
    }
  }

File Information:

file name:FitnessFunction.java
package:org.dgpf.search.api
qualified name:org.dgpf.search.api.FitnessFunction.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/search/api/FitnessFunction.java
size:10.100 KB (10343 B)
uploaded: 2015-07-22 04:11:00 GMT+0000
last update: 2006-08-22 11:02:51 GMT+0000
last access: 2017-11-17 21:24:34 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2017-11-17 21:24:34 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo