Logo
Distributed Genetic Programming Framework
print print

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

Here you can find all the information about the file org.dgpf.gp.regression.base.ExpressionSet.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 14:57:54
 * Original Filename: org.dgpf.gp.regression.base.ExpressionSet.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.base;

import org.dgpf.gp.regression.search.MutationInfo;
import org.dgpf.search.api.utils.WeightedSet;
import org.dgpf.search.api.utils.WeightedSetBuilder;
import org.sfc.math.stochastic.Randomizer;

/**
 * An expression set enables a context to create and manipulate expressions.
 *
 * @author Thomas Weise
 */

public class ExpressionSet extends     WeightedSet<IExpressionHandler>  
                           implements  IWrapableExpressionHandler
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  
/**
 * The weighted set with the wrapable expression handlers.
 */

  private final WeightedSet<IWrapableExpressionHandler> m_wrapables ;
  
/**
 * Create a new expression set. Expression sets are fixed and cannot be
 * modified.
 * @param p_wsb The weighted set builder to use. 
 */

  public  ExpressionSet(final WeightedSetBuilder<IExpressionHandler> p_wsb)
    {
    super(p_wsb);
    
    int                 l_i;
    IExpressionHandler  l_h;
    
    WeightedSetBuilder<IWrapableExpressionHandler>  l_w;
    
    l_w = new WeightedSetBuilder<IWrapableExpressionHandler>(
                                  IWrapableExpressionHandler.class);
    
    for(l_i = (p_wsb.get_count()-1); l_i >= 0; l_i--)
      {
      l_h = p_wsb.get(l_i);
      if(l_h instanceof IWrapableExpressionHandler)
        {
        l_w.add(((IWrapableExpressionHandler)l_h), p_wsb.get_weight(l_i));
        }
      }
    
    this.m_wrapables = new WeightedSet<IWrapableExpressionHandler>(l_w);
    }
  

/**
 * Create a new randomized instance of one of the expressions this handler
 * stands for.
 * @param p_context The vm 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)
    {
    Randomizer                              l_r;
    Expression                              l_c;
    WeightedSet<IExpressionHandler>.Session l_s;
    IExpressionHandler                      l_h;
    
    l_r = p_context.get_randomizer();
    p_info.down();
    l_c = null;
    
main:
    for(;;)
      {
      l_s = this.open_session(l_r);
      
inner:
      while(l_s.hasNext())
        {
        l_h = l_s.next();
        if(l_h.is_terminal() || p_info.can_non_terminal(l_r))
          {
          l_c = l_h.create(p_context, p_info);
          if(l_c != null)
            {
            break inner;
            }
          }
        }
      
      l_s.close();
      if(l_c != null) break main;
      } 
    
    p_info.up();
    
    return l_c.get_handler().optimize(l_c);
    }
  
/**
 * Perform the mutation.
 * @param p_source  The source object to create a randomizedly altered
 *                  copy of.
 * @param p_context The context hosting the operation.
 * @param p_info    The information record.
 * @return  The new, randomizedly altered copy of the object
 *          <code>p_source</code> or <code>p_source</code> itself if no
 *          mutation was possible.
 */

  public  final Expression mutate  (final Expression        p_source,
                                    final AggregationContext p_context,
                                    final MutationInfo      p_info)
    {
    return p_source.get_handler().mutate(p_source, p_context, p_info);
    }
  

/**
 * Obtain the set of the wrapable expression handlers.
 * @return The set of the wrapable expression handlers.
 */

  public  final WeightedSet<IWrapableExpressionHandler> get_wrapables()
    {
    return this.m_wrapables;
    }
  


/**
 * 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  (final Expression        p_expression,
                                   final AggregationContext p_context,
                                   final MutationInfo      p_info)
    {
    WeightedSet<IWrapableExpressionHandler>.Session l_s;
    Expression                                      l_e;
    IWrapableExpressionHandler                      l_h;
    
    l_s = this.m_wrapables.open_session(p_context.get_randomizer());
    
    while(l_s.hasNext())
      {
      l_h = l_s.next();
      l_e = l_h.wrap(p_expression, p_context, p_info);
      
      if( ! ( (l_e == null) || l_e.equals(p_expression) ) )
        {
        l_s.close();
        return l_e;
        }
      }
    
    l_s.close();
    return 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.
 */

  public  final Expression  replace_sub_expression
                                        (final AggregationContext p_context,
                                         final Expression        p_source,
                                         final Expression        p_old,
                                         final Expression        p_repl)
    {
    if((p_old == p_source) || ((p_old != null) && (p_old.equals(p_source))))
      {
      return p_repl;
      }
    
    return p_source.get_handler().replace_sub_expression(p_context,
                                               p_source, p_old, 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.get_handler().get_sub_expression(p_context, 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  final boolean     is_terminal ()
    {
    return true;
    }
  

/**
 * 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  final Expression  optimize  (final Expression p_source)
    {
    return p_source.get_handler().optimize(p_source);
    }
  

/**
 * 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)
    {
    WeightedSet<IWrapableExpressionHandler>.Session l_s;
    Expression                                      l_e;
    IWrapableExpressionHandler                      l_h;
    
    l_s = this.m_wrapables.open_session(p_context.get_randomizer());
    
    while(l_s.hasNext())
      {
      l_h = l_s.next();
      l_e = l_h.wrap2(p_expr_1, p_expr_2, p_context, p_info);
      
      if( !((l_e == null) || l_e.equals(p_expr_1) || l_e.equals(p_expr_2)))
        {
        l_s.close();
        return l_e;
        }
      }
    
    l_s.close();
    return null;
    }
  

/**
 * 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.get_handler().replace_var(p_source, p_old_var,
                                              p_new_var);
    }
  }

File Information:

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