Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.regression.expressions.DefaultExpressionHandler.java

Here you can find all the information about the file org.dgpf.gp.regression.expressions.DefaultExpressionHandler.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-25 13:51:10
 * Original Filename: org.dgpf.gp.regression.expressions.DefaultExpressionHandler.java
 * Version          : 1.0.0
 * Last modification: 2006-07-25
 *                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.expressions;

import org.dgpf.gp.regression.base.Expression;
import org.dgpf.gp.regression.base.IExpressionHandler;
import org.dgpf.gp.regression.base.AggregationContext;
import org.dgpf.gp.regression.search.MutationInfo;
import org.dgpf.search.api.utils.IMutator;
import org.dgpf.search.api.utils.WeightedMutator;
import org.dgpf.search.api.utils.WeightedSetBuilder;

/**
 * The basic handler class for expressions.
 *
 * @author Thomas Weise
 */

public abstract class DefaultExpressionHandler
                extends     WeightedMutator<Expression, AggregationContext,
                                            MutationInfo>
                implements  IExpressionHandler
  {
/**
 * The serial version uid.
 */

  private static  final long  serialVersionUID = 1;
  
  
/**
 * The internal mutator for wrapping an expression.
 */

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> MUT_WRAP =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression        p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo      p_info)
        {
        return p_context.get_expression_set().wrap(p_source, p_context,
                                                   p_info);
        }
      };

/**
 * The first sub-expression mutator weight.
 */

  protected static  final double  MUT_WRAP_WEIGHT = 1.0d;
      
/**
 * The default weighted set builder.
 */

  static  final WeightedSetBuilder<IMutator
                           <Expression, AggregationContext, MutationInfo>>
    MB = new WeightedSetBuilder<IMutator
             <Expression, AggregationContext, MutationInfo>>(IMutator.class);
  
  static
    {
    MB.add(MUT_WRAP, MUT_WRAP_WEIGHT);
    }
   
/**
 * Create a new mem instr 1 handler. Such handlers use internal mutator
 * lists.
 * @param p_wsb The weighted set builder to use. Leave this
 *              <code>null</code> if no additional mutators are needed. 
 */

  protected DefaultExpressionHandler(final WeightedSetBuilder<IMutator
                     <Expression, AggregationContext, MutationInfo>> p_wsb)
    {
    super(build_set(p_wsb));
    }
  
/**
 * The internal set conversion routine.
 * @param p_set The normal mutator set.
 * @return  The modified mutator set.
 */

  private static final WeightedSetBuilder<IMutator
                       <Expression, AggregationContext, MutationInfo>> build_set
                       (final WeightedSetBuilder<IMutator
                        <Expression, AggregationContext, MutationInfo>> p_set)
    {
    if(p_set == null) return MB;
    
    if(!(p_set.contains(MUT_WRAP))) p_set.add(MUT_WRAP, MUT_WRAP_WEIGHT);
    
    return p_set;
    }
  


/**
 * Replace a sub-expression by the expression passed in.
 * @param p_source  The source expression.
 * @param p_context The regression context to be used.
 * @param p_old     The old expression that should be replaced, or
 *                  <code>null</code> if a randomly chosen one will be
 *                  replaced.
 * @param p_repl    A replacement expression for a randomly chose
 *                  sub-expression of the source expression.
 * @return  <code>p_source</code> with one of its sub-expressions replaced
 *          by <code>p_repl</code>, or <code>p_repl</code> if no
 *          sub-expression can be replaced.
 */

  public Expression replace_sub_expression
                                        (final AggregationContext p_context,
                                         final Expression        p_source,
                                         final Expression        p_old,
                                         final Expression        p_repl)
    {
    return p_repl;
    }
  
/**
 * Obtain a randomly chosen sub-expression.
 * @param p_context The regression context to be used.
 * @param p_source  The source expression.
 * @return  A randomly chosen sub-expression of <code>p_source</code> or
 *          <code>p_source</code> itself.
 */

  public  Expression  get_sub_expression(final AggregationContext p_context,
                                         final Expression        p_source)
    {
    return p_source;
    }
  


/**
 * Check whether the expressions created by this handler are terminal
 * expressions or not.
 * @return  <code>true</code> if and only if the expressions created by
 *          this handler are terminal.
 */

  public  boolean     is_terminal ()
    {
    return false;
    }
  

/**
 * Optimize an expression.
 * @param p_source  The source expression to be optimized.
 * @return  The optimized version of the source expression, or the source
 *          expression itsef.
 */

  public   Expression  optimize  (final Expression p_source)
    {
    return p_source;
    }
  

/**
 * Replace a variable in all sub expressions.
 * @param p_source  The source expression to replace the variable in.
 * @param p_old_var The old variable to be replaced.
 * @param p_new_var The new replacement.
 * @return  The expression <code>p_source</code>, where all occurences of
 *          <code>p_old_var</code> have been replaced by
 *          <code>p_new_var</code>.
 */

  public        Expression  replace_var(final Expression p_source,
                                        final int        p_old_var,
                                        final int        p_new_var)
    {
    return p_source;
    }
  }

File Information:

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