Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.regression.expressions.unary.UnaryExpressionHandler.java

Here you can find all the information about the file org.dgpf.gp.regression.expressions.unary.UnaryExpressionHandler.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.binary.BinaryExpressionHandler.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.unary;

import org.dgpf.gp.regression.base.AggregationContext;
import org.dgpf.gp.regression.base.Expression;
import org.dgpf.gp.regression.base.ExpressionSet;
import org.dgpf.gp.regression.base.IExpressionHandler;
import org.dgpf.gp.regression.base.IWrapableExpressionHandler;
import org.dgpf.gp.regression.expressions.DefaultExpressionHandler;
import org.dgpf.gp.regression.search.MutationInfo;
import org.dgpf.search.api.utils.IMutator;
import org.dgpf.search.api.utils.WeightedSet;
import org.dgpf.search.api.utils.WeightedSetBuilder;

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

public abstract class UnaryExpressionHandler
                extends     DefaultExpressionHandler
                implements  IWrapableExpressionHandler
  {
/**
 * The serial version uid.
 */

  private static  final long  serialVersionUID = 1;
  
  
/**
 * The internal mutator which mutates the sub-expression.
 */

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> MUT =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression        p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo      p_info)
        {
        UnaryExpression l_b;
        Expression       l_e, l_n;

        l_b = ((UnaryExpression)p_source);
        l_e = l_b.get_sub();
        
        l_n = l_e.get_handler().mutate(l_e, p_context, p_info);
        if( (l_n != null) && (!(l_n.equals(l_e))) )
          {
          l_b = ((UnaryExpression)(l_b.clone()));
          l_b.set_sub(l_n);
          return l_b;
          }
        
        return p_source;
        }
      };

      

/**
 * The internal mutator which replaces the sub-expression.
 */

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> REP =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression        p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo      p_info)
        {
        UnaryExpression l_b;
        Expression       l_e, l_n;
        
        l_b = ((UnaryExpression)p_source);
        l_e = l_b.get_sub();
        
        do
          {
          p_info.begin_expression();
          l_n = p_context.get_expression_set().create(p_context, p_info);
          } while((l_n == null) || (l_n.equals(l_e)));
          
        l_b = ((UnaryExpression)(l_b.clone()));
        l_b.set_sub(l_n);
        return l_b;
        }
      };


/**
 * The internal mutator which lifts the sub-expression.
 */

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> MUT_LIFT =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression        p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo      p_info)
        {
        UnaryExpression l_b;
        
        l_b = ((UnaryExpression)p_source);       
        return l_b.get_sub();
        }
      };
      

/**
 * The internal mutator which replaces the operator itself.
 */

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> REP_OP =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression         p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo       p_info)
        {
        UnaryExpression                        l_b;
        WeightedSet<IExpressionHandler>.Session l_s;
        IExpressionHandler                      l_eh;
        Expression                              l_e, l_r;
        
        l_b = ((UnaryExpression)p_source);
        l_s = p_context.get_expression_set().open_session(
                      p_context.get_randomizer());
        l_e = l_b.m_sub;
        
        while(l_s.hasNext())
          {
          l_eh = l_s.next();
          if(l_eh instanceof UnaryExpressionHandler)
            {
            l_r = ((UnaryExpressionHandler)l_eh).do_create(l_e);
            if((l_r != null) && (!(l_r.equals(l_b))))
              {
              l_s.close();
              return l_r;
              }
            }
          }
        
        l_s.close();
        return p_source;
        }
      };

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

      static  final double  MUT_WEIGHT    = (2.0d * MUT_WRAP_WEIGHT);
/**
 * The replace-operator mutator weight.
 */

      static  final double  MUT_RO_WEIGHT   = (MUT_WEIGHT);
/**
 * The sub-expression replacer weight.
 */

      static  final double  REP_WEIGHT    = (MUT_WEIGHT*0.05d);
/**
 * The sub-expression lifter weight.
 */

      static  final double  MUT_LIFT_WEIGHT = (2.2d * MUT_WEIGHT);
      
/**
 * The default weighted set builder.
 */

  static  final WeightedSetBuilder<IMutator
                           <Expression, AggregationContext, MutationInfo>>
    MI1B = new WeightedSetBuilder<IMutator
             <Expression, AggregationContext, MutationInfo>>(IMutator.class);
  
  static
    {
    MI1B.add(MUT,      MUT_WEIGHT);    
    MI1B.add(MUT_LIFT, MUT_LIFT_WEIGHT);
    MI1B.add(REP,      REP_WEIGHT);    
    MI1B.add(REP_OP,   MUT_RO_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 UnaryExpressionHandler(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 MI1B;
    
    if(!(p_set.contains(MUT)))      p_set.add(MUT,    MUT_WEIGHT);   
    if(!(p_set.contains(REP)))      p_set.add(REP,    REP_WEIGHT);        
    if(!(p_set.contains(MUT_LIFT))) p_set.add(MUT_LIFT, MUT_LIFT_WEIGHT); 
    if(!(p_set.contains(REP_OP)))   p_set.add(REP_OP,   MUT_RO_WEIGHT);
    
    return p_set;
    }
  
/**
 * Create an expression of the type this handler handles using the
 * specified sub-expressions.
 * @param p_sub   The sub-expression.
 * @return  The newly created expression with the two sub-expressions.
 */

  public abstract  Expression  do_create (final Expression p_sub);
  
  
/**
 * Create a new randomized instance of the expression handled by this
 * handler.
 * @param p_context The regression context to be used.
 * @param p_info    The information record holding the infos on the
 *                  expression to be created.
 * @return  The new expression instance.
 */

  public  final Expression  create (final AggregationContext  p_context,
                                    final MutationInfo        p_info)
    {
    ExpressionSet l_se;
    
    l_se = p_context.get_expression_set();
   
    return this.do_create(l_se.create(p_context, p_info));
    }
  

/**
 * Wrap the specified expression into another one.
 * @param p_expression  The expression to be wrapped.
 * @param p_context     The context hosting this operation.
 * @param p_info        The mutation information record to use.
 * @return A new expression, containing the specified one as sub-expression
 *         or <code>p_expression</code> if wrapping was not successful.
 */

  public  final Expression  wrap  (      Expression        p_expression,
                                   final AggregationContext p_context,
                                   final MutationInfo      p_info)
    {
    return this.do_create(p_expression);
    }
  


/**
 * 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.
 */

  @Override
  public  final Expression  replace_sub_expression
                                        (final AggregationContext p_context,
                                         final Expression        p_source,
                                         final Expression        p_old,
                                         final Expression        p_repl)
    {
    UnaryExpression l_b;    
    
    if((p_old == p_source) || ((p_old != null) && (p_old.equals(p_source))))
      {
      return p_repl;
      }
    
    l_b = ((UnaryExpression)(p_source.clone()));
      
    if(p_old == null)
      {
      if( p_context.get_randomizer().nextBoolean() )
        {
        return p_repl;
        }
      
      l_b.set_sub(p_repl);
      }
    else
      {
      if(p_old.equals(l_b.m_sub))
        {
        l_b = ((UnaryExpression)(l_b.clone()));
        l_b.m_sub = p_repl;
        }
      }
    return l_b;
    }
  
/**
 * 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.
 */

  @Override
  public  Expression  get_sub_expression(final AggregationContext p_context,
                                         final Expression        p_source)
    {
    UnaryExpression l_b;   
    
    if( p_context.get_randomizer().nextBoolean())
      {
      return p_source;
      }
        
    l_b = ((UnaryExpression)p_source);
    
    return l_b.get_sub();  
    }
  
  
  

/**
 * 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>.
 */

  @Override
  public        Expression  replace_var(final Expression p_source,
                                        final int        p_old_var,
                                        final int        p_new_var)
    {
    Expression       l_e1;
    UnaryExpression l_b;
    
    l_b  = ((UnaryExpression)p_source);
    l_e1 = l_b.m_sub;
    l_e1 = l_e1.get_handler().replace_var(l_e1, p_old_var, p_new_var);
    
    if(l_e1 == l_b.m_sub) return p_source;
    
    l_b       = ((UnaryExpression)(l_b.clone()));
    l_b.m_sub = l_e1;
    
    return l_b;
    }
  


/**
 * Try to wrap the specified expressions.
 * @param p_expr_1      The first expression to be wrapped.
 * @param p_expr_2      The second expression to be wrapped.
 * @param p_context     The context hosting this operation.
 * @param p_info        The mutation information record to use.
 * @return A new expression, containing the specified one as sub-expression
 *         or <code>null</code> if wrapping was not successful.
 */

  public  final Expression  wrap2 (final Expression        p_expr_1,
                                   final Expression        p_expr_2,
                                   final AggregationContext p_context,
                                   final MutationInfo      p_info)
    {
    return null;
    }
  }

File Information:

file name:UnaryExpressionHandler.java
package:org.dgpf.gp.regression.expressions.unary
qualified name:org.dgpf.gp.regression.expressions.unary.UnaryExpressionHandler.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/regression/expressions/unary/UnaryExpressionHandler.java
size:13.595 KB (13922 B)
uploaded: 2015-07-22 04:10:56 GMT+0000
last update: 2006-08-17 03:38:47 GMT+0000
last access: 2017-11-18 23:21:37 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 23:21:37 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo