Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.regression.expressions.binary.BinaryExpressionHandler.java

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

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;
import org.sfc.math.stochastic.Randomizer;

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

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

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

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

        l_b = ((BinaryExpression)p_source);
        l_e = l_b.get_sub_1();
        
        l_n = l_e.get_handler().mutate(l_e, p_context, p_info);
        if( (l_n != null) && (!(l_n.equals(l_e))) )
          {
          l_b = ((BinaryExpression)(l_b.clone()));
          l_b.set_sub_1(l_n);
          return l_b;
          }
        
        return p_source;
        }
      };

/**
 * The internal mutator which mutates the second sub-expression.
 */

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

        l_b = ((BinaryExpression)p_source);
        l_e = l_b.get_sub_2();
        
        l_n = l_e.get_handler().mutate(l_e, p_context, p_info);
        if( (l_n != null) && (!(l_n.equals(l_e))) )
          {
          l_b = ((BinaryExpression)(l_b.clone()));
          l_b.set_sub_2(l_n);
          return l_b;
          }
        
        return p_source;
        }
      };
      
      

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

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> REP_1 =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression        p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo      p_info)
        {
        BinaryExpression l_b;
        Expression       l_e, l_n;
        
        l_b = ((BinaryExpression)p_source);
        l_e = l_b.get_sub_1();
        
        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 = ((BinaryExpression)(l_b.clone()));
        l_b.set_sub_1(l_n);
        return l_b;
        }
      };

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

  private static  final IMutator<Expression, AggregationContext,
                                 MutationInfo> REP_2 =
    new IMutator<Expression, AggregationContext, MutationInfo>()
      {
      public  final  Expression  mutate  (final Expression        p_source,
                                          final AggregationContext p_context,
                                          final MutationInfo      p_info)
        {
        BinaryExpression l_b;
        Expression       l_e, l_n;
        
        l_b = ((BinaryExpression)p_source);
        l_e = l_b.get_sub_2();
        
        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 = ((BinaryExpression)(l_b.clone()));
        l_b.set_sub_2(l_n);
        return l_b;
        }
      };
      

/**
 * The internal mutator which lifts one of the sub-expressions.
 */

  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)
        {
        BinaryExpression l_b;
        
        l_b = ((BinaryExpression)p_source);       
        return (p_context.get_randomizer().nextBoolean() ?
                l_b.get_sub_1() : l_b.get_sub_2());
        }
      };
      

/**
 * 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)
        {
        BinaryExpression                        l_b;
        WeightedSet<IExpressionHandler>.Session l_s;
        IExpressionHandler                      l_eh;
        Expression                              l_e1, l_e2, l_r;
        
        l_b = ((BinaryExpression)p_source);
        l_s = p_context.get_expression_set().open_session(
                      p_context.get_randomizer());
        l_e1 = l_b.m_sub_1;
        l_e2 = l_b.m_sub_2;
        
        while(l_s.hasNext())
          {
          l_eh = l_s.next();
          if(l_eh instanceof BinaryExpressionHandler)
            {
            l_r = ((BinaryExpressionHandler)l_eh).do_create(l_e1, l_e2);
            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_1_WEIGHT    = (2.0d * MUT_WRAP_WEIGHT);
/**
 * The second sub-expression mutator weight.
 */

      static  final double  MUT_2_WEIGHT    = (MUT_1_WEIGHT);
/**
 * The replace-operator mutator weight.
 */

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

      static  final double  REP_1_WEIGHT    = (0.05d * MUT_1_WEIGHT);
/**
 * The second sub-expression replacer weight.
 */

      static  final double  REP_2_WEIGHT    = (REP_1_WEIGHT);
/**
 * The sub-expression lifter weight.
 */

      static  final double  MUT_LIFT_WEIGHT = (2.2d * MUT_1_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_1,    MUT_1_WEIGHT);    
    MI1B.add(MUT_2,    MUT_2_WEIGHT);    
    MI1B.add(MUT_LIFT, MUT_LIFT_WEIGHT);
    MI1B.add(REP_1,    REP_1_WEIGHT);    
    MI1B.add(REP_2,    REP_2_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 BinaryExpressionHandler(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_1)))    p_set.add(MUT_1,    MUT_1_WEIGHT);    
    if(!(p_set.contains(MUT_2)))    p_set.add(MUT_2,    MUT_2_WEIGHT);  
    if(!(p_set.contains(REP_1)))    p_set.add(REP_1,    REP_1_WEIGHT);    
    if(!(p_set.contains(REP_2)))    p_set.add(REP_2,    REP_2_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_1   The first sub-expression.
 * @param p_sub_2   The second sub-expression.
 * @return  The newly created expression with the two sub-expressions.
 */

  public abstract  Expression  do_create (final Expression p_sub_1,
                                          final Expression p_sub_2);
  
  
/**
 * 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),
                          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)
    {
    Expression  l_e1, l_e2;
    
    p_info.begin_expression();
    l_e1 = p_context.get_expression_set().create(p_context, p_info);
    
    if(p_context.get_randomizer().nextBoolean())
      {
      l_e2         = p_expression;
      p_expression = l_e1;
      l_e1         = l_e2;
      }
    
    return this.do_create(p_expression, l_e1);
    }
  


/**
 * 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)
    {
    BinaryExpression l_b;    
    int              l_i;
    
    if((p_old == p_source) || ((p_old != null) && (p_old.equals(p_source))))
      {
      return p_repl;
      }
    
    l_b = ((BinaryExpression)(p_source.clone()));
      
    if(p_old == null)
      {
      if( (l_i = p_context.get_randomizer().nextInt(4)) <= 1 )
        {
        return p_repl;
        }
          
      if(l_i == 2)
        {
        l_b.set_sub_1(p_repl);
        return l_b;
        }
      
      l_b.set_sub_2(p_repl);
      }
    else
      {
      if(p_old.equals(l_b.m_sub_1))
        {
        l_b = ((BinaryExpression)(l_b.clone()));
        l_b.m_sub_1 = p_repl;
        }
        
      if(p_old.equals(l_b.m_sub_2))
        {
        if(l_b == p_source) l_b = ((BinaryExpression)(l_b.clone()));
        l_b.m_sub_2 = 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)
    {
    BinaryExpression l_b;    
    int              l_i;
    
    if( (l_i = p_context.get_randomizer().nextInt(4)) <= 0 )
      {
      return p_source;
      }
        
    l_b = ((BinaryExpression)p_source);
    
    if(l_i == 2) return l_b.get_sub_1();    
    return l_b.get_sub_2();
    }
  
  

/**
 * 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)
    {
    Randomizer    l_r;
    ExpressionSet l_es;
    
    l_r  = p_context.get_randomizer();
    l_es = p_context.get_expression_set();
    
    return this.do_create(
      l_r.nextBoolean() ? p_expr_1 : l_es.wrap(p_expr_1, p_context, p_info),
      l_r.nextBoolean() ? p_expr_2 : l_es.wrap(p_expr_2, p_context, p_info)
          );
    }
  

/**
 * 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, l_e2;
    BinaryExpression l_b;
    
    l_b  = ((BinaryExpression)p_source);
    l_e1 = l_b.m_sub_1;
    l_e1 = l_e1.get_handler().replace_var(l_e1, p_old_var, p_new_var);
    l_e2 = l_b.m_sub_2;
    l_e2 = l_e2.get_handler().replace_var(l_e2, p_old_var, p_new_var);
    
    if((l_e1 == l_b.m_sub_1) && (l_e2 == l_b.m_sub_2)) return p_source;
    
    l_b         = ((BinaryExpression)(l_b.clone()));
    l_b.m_sub_1 = l_e1;
    l_b.m_sub_2 = l_e2;
    
    return l_b;
    }
  }

File Information:

file name:BinaryExpressionHandler.java
package:org.dgpf.gp.regression.expressions.binary
qualified name:org.dgpf.gp.regression.expressions.binary.BinaryExpressionHandler.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/regression/expressions/binary/BinaryExpressionHandler.java
size:17.616 KB (18039 B)
uploaded: 2015-07-22 04:10:56 GMT+0000
last update: 2006-08-14 10:12:19 GMT+0000
last access: 2017-11-17 21:19:15 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:19:15 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo