Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.regression.base.AggregationDefinition.java

Here you can find all the information about the file org.dgpf.gp.regression.base.AggregationDefinition.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-07-24 15:09:09
 * Original Filename: org.dgpf.gp.regression.RegressionDefinition.java
 * Version          : 1.0.0
 * Last modification: 2006-07-24
 *                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.gp.regression.base;

import org.dgpf.search.api.FitnessFunction;
import org.dgpf.search.api.SearchContext;
import org.dgpf.search.api.SearchDefinition;
import org.sfc.events.IEventListener;
import org.sfc.math.Mathematics;
import org.sfc.utils.ICloneable;
import org.sfc.utils.Typesafe;

/**
 * This is the search definition used for regression tasks.
 *
 * @author Thomas Weise
 */

public class AggregationDefinition extends SearchDefinition<Calculation>
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  
/**
 * The maximum count of variables available.
 * @see #get_max_variables()
 */

  private int                 m_max_variables ;
/**
 * The maximum count of formulas allowed in one calculation.
 * @see #get_max_formulas()
 */
 
  private int                 m_max_formulas ;
/**
 * The count of target variables.
 * @see #get_target_count()
 */

  private int                 m_target_count  ;
  
/**
 * The set of available expressions which can be used in calculations.
 * @see #get_expression_set()
 */

  private ExpressionSet       m_expressions ;
  
/**
 * The count of calculators/nodes participating in this aggregation
 * function regression.
 * @see #get_node_count()
 */

  private int                 m_node_count  ;  
/**
 * The network implementation factory.
 * @see #get_network_impl_factory()
 */

  private INetworkImplFactory m_net_factory ;
/**
 * The maximum allowed formula depth.
 * @see #get_max_depth()
 */

  private       int                 m_max_depth ;
  
/**
 * Create a new regression definition.
 * @param p_definition  The search definition to use as blueprint for the
 *                      internally stored data.
 */

  public  AggregationDefinition(final AggregationDefinition p_definition)
    {
    super(p_definition);
    }
 
/**
 * Create a new regression definition.
 * @param p_functions   The fitness functions to be applied in this
 *                      evolution.
 */

  public AggregationDefinition(
                  FitnessFunction<Calculation,?>[] p_functions)
    {
    super(p_functions = prepare(p_functions));
    
    int                        l_i, l_j;
    AggregationFitnessFunction l_f;
    
    this.m_max_formulas   = AggregationUtils.DEFAULT_MAX_FORMULAS;
    this.m_max_variables  = AggregationUtils.DEFAULT_MAX_VARIABLES;
    this.m_expressions    = AggregationUtils.DEFAULT_EXPRESSION_SET;
    
    this.m_node_count     = AggregationUtils.DEFAULT_NODE_COUNT;
    this.set_steps_per_simulation(AggregationUtils.DEFAULT_STEPS_PER_SIMULATION);
    this.set_simulation_count(AggregationUtils.DEFAULT_SIMULATION_COUNT);
    
    this.m_net_factory    = AggregationUtils.DEFAULT_NETWORK_IMPL_FACTORY;
    
    l_j = -1;
    for(l_i = (p_functions.length-1); l_i >= 0; l_i--)
      {
      if(p_functions[l_i] instanceof AggregationFitnessFunction)
        {
        l_f = Typesafe.cast(p_functions[l_i]);
        l_j = Math.max(l_j, l_f.m_ti);
        }
      }
    
    this.m_target_count   = (l_j+1);
    this.m_max_depth      = AggregationUtils.DEFAULT_MAX_DEPTH;
    }
  
/**
 * Prepare the function array.
 * @param p_functions   The fitness functions to be applied in this
 *                      evolution.
 * @return The refined fitness functions to be applied in this evolution.
 */

  private static  final FitnessFunction<Calculation,?>[] prepare
    (final FitnessFunction<Calculation,?>[] p_functions)
    {
    int                        l_i, l_j;
    AggregationFitnessFunction l_f;
    
    l_j = 0;
    for(l_i = (p_functions.length-1); l_i >= 0; l_i--)
      {
      if(p_functions[l_i] instanceof AggregationFitnessFunction)
        {
        p_functions[l_i] = l_f = ((AggregationFitnessFunction)(((ICloneable)
            p_functions[l_i]).clone()));
        l_f.m_ti = (l_j++);
        }
      }
    
    return p_functions;
    }
   

/**
 * Using this method, a search definition works as factory for search
 * contexts. You must override it to provide a real search context.
 * 
 * @param p_events  The event propagator to be used to propagate error
 *                  events, if needed.
 * 
 * @return A new search context.
 */

  @Override
  public SearchContext<Calculation> create_context
                                          (final IEventListener p_events)
    {
    return new AggregationContext(this, p_events);
    }
  

/**
 * Obtain the count of calculators/nodes participating in this aggregation
 * function regression.
 * @return  The count of calculators/nodes participating in this
 *          aggregation function regression.
 */

  public  final int get_node_count()
    {
    return this.m_node_count;
    }
  
/**
 * Set the count of nodes participating in this aggregation function
 * regression.
 * @param p_count The new count of nodes participating in this aggregation
 *                function regression.
 */

  public  final void  set_node_count  (final int p_count)
    {
    if(p_count > 1) this.m_node_count = p_count;
    }
  


/**
 * Obtain the maximum count of variables available.
 * @return The maximum count of variables available.
 */

  public  final int get_max_variables ()
    {
    return this.m_max_variables;
    }
  
/**
 * The maximum count of allowed variables.
 * @param p_max_variables   The new maximum count of allowed variables.
 */

  public  final void  set_max_variables (final int p_max_variables)
    {
    if(p_max_variables > 0) this.m_max_variables = p_max_variables;
    }
  
/**
 * Obtain the maximum count of formulas allowed in one calculation.
 * @return  The maximum count of formulas allowed in one calculation.
 */

  public  final int get_max_formulas ()
    {
    return this.m_max_formulas;
    }
  
/**
 * Set the maximum count of formulas allowed in one calculation.
 * @param p_max_formulas  The new maximum count of formulas allowed in one
 *                        calculation.
 */

  public  final void  set_max_formulas  (final int p_max_formulas)
    {
    if(p_max_formulas > 0) this.m_max_formulas = p_max_formulas;
    }
  
/**
 * Assign the internal data of this search data to the data of
 * another one.
 * @param p_data  The simulation data  to assign to.
 */

  @Override
  public void  assign  (final Object p_data)
    {
    AggregationContext     l_rc;
    AggregationDefinition  l_rd;
    
    if(p_data instanceof AggregationContext)
      {
      l_rc = ((AggregationContext)p_data);
      this.set_max_formulas(l_rc.get_max_formulas());
      this.set_max_variables(l_rc.get_max_variables());
      this.set_expression_set(l_rc.get_expression_set());
      this.m_target_count = l_rc.get_target_count();
      this.set_node_count(l_rc.get_node_count());
      this.set_network_impl_factory(l_rc.get_network_impl_factory());
      this.set_max_depth(l_rc.get_max_depth());
      }
    else if(p_data instanceof AggregationDefinition)
      {
      l_rd = ((AggregationDefinition)p_data);
      this.set_max_formulas(l_rd.m_max_formulas);
      this.set_max_variables(l_rd.m_max_variables);
      this.set_expression_set(l_rd.m_expressions);
      this.m_target_count = l_rd.m_target_count;
      this.set_node_count(l_rd.m_node_count);
      this.set_network_impl_factory(l_rd.m_net_factory);
      this.set_max_depth(l_rd.get_max_depth());
      }    
    
    super.assign(p_data);
    }
  

/**
 * Obtain the set of available expressions which can be used in
 * calculations.
 * @return  The set of available expressions which can be used in
 *          calculations.
 */

  public  final ExpressionSet get_expression_set()
    {
    return this.m_expressions;
    }
  
/**
 * Set the set of available expressions which can be used in
 * calculations.
 * @param p_expressions The new set of available expressions.
 */

  public  final void  set_expression_set(final ExpressionSet p_expressions)
    {
    if((p_expressions != null) && (!(p_expressions.isEmpty())))
      {
      this.m_expressions = p_expressions;
      }
    }
  
/**
 * Obtain the count of target variables.
 * @return The count of target variables.
 */

  public  final int get_target_count()
    {
    return this.m_target_count;
    }
  
/**
 * Obtain the network implementation factory.
 * @return The network implementation factory used to power up the network
 *         simulation.
 */

  public  final INetworkImplFactory get_network_impl_factory  ()
    {
    return this.m_net_factory;
    }
  
/**
 * Set the network implementation factory to be used by contexts derived
 * from this definition.
 * @param p_factory   The network implementation factory to be used by
 *                    contexts derived from this definition.
 */

  public  final void  set_network_impl_factory(
                          final INetworkImplFactory p_factory)
    {
    if(p_factory != null)
      {
      this.m_net_factory = p_factory;
      }
    }
  
  
/**
 * Set the count of simulations to be performed for every individual
 * (genotype) to determine a stable fitness value.
 * @param p_simulation_count  How many simulations will be needed
 *                            per individual.
 */

  @Override
  public     void  set_simulation_count  (final int p_simulation_count)
    {
    super.set_simulation_count(AggregationContext.MAX_SIM * Math.max(1,
    Mathematics.ceil_div(p_simulation_count, AggregationContext.MAX_SIM)));
    }
  
/**
 * Obtain the maximum formula depth.
 * @return The maximum formula depth.
 */

  public  int get_max_depth()
    {
    return this.m_max_depth;
    }
  
/**
 * Set the maximum formula depth.
 * @param p_max_depth The new maximum formula depth.
 */

  public  void  set_max_depth(final int p_max_depth)
    {
    this.m_max_depth = p_max_depth;
    }
  }

File Information:

file name:AggregationDefinition.java
package:org.dgpf.gp.regression.base
qualified name:org.dgpf.gp.regression.base.AggregationDefinition.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/regression/base/AggregationDefinition.java
size:10.911 KB (11173 B)
uploaded: 2015-07-22 04:10:56 GMT+0000
last update: 2006-09-06 04:11:44 GMT+0000
last access: 2017-11-17 21:08:58 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:08:58 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo