Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.automaton.expressions.UnaryExpressionHandler.java

Here you can find all the information about the file org.dgpf.gp.automaton.expressions.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-02-07 06:37:50
 * Original Filename: org.dgpf.automaton.expressions.UnaryExpressionHandler.java
 * Version          : 2.2.1
 * Last modification: 2006-05-08
 *                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.automaton.expressions;

import org.dgpf.gp.automaton.base.Expression;
import org.dgpf.gp.automaton.expressions.BinaryExpression.BinaryOperation;
import org.dgpf.gp.automaton.expressions.UnaryExpression.UnaryOperation;
import org.dgpf.gp.automaton.search.Mutator;
import org.dgpf.gp.automaton.search.ProgramContext;
import org.dgpf.gp.automaton.search.WrapableExpressionHandler;
import org.sfc.collections.Arrays;
import org.sfc.math.stochastic.Randomizer;
import org.sfc.utils.Typesafe;

/**
 * This class handles unary expressions.
 *
 * @author Thomas Weise
 */

final class   UnaryExpressionHandler
      extends WrapableExpressionHandler<UnaryExpression>
  {
/**
 * The decisional unary operations.
 */

  static  final UnaryOperation[] DECISIONAL  = new UnaryOperation[]
      { UnaryExpression.LNOT };

/**
 * The calculative unary operations.
 */

  static  final UnaryOperation[] CALCULATIVE = new UnaryOperation[]
      { UnaryExpression.BNOT,
        UnaryExpression.MINUS };

/**
 * The predefined unary operations.
 */

  static  final UnaryOperation[][]  CLASSES = new UnaryOperation[][]
     {DECISIONAL, CALCULATIVE};


  static
    {
    UnaryOperation    l_op;
    UnaryOperation[]  l_uo;
    int               l_i, l_j;

    for(l_i = (CLASSES.length-1); l_i >= 0; l_i--)
      {
      l_uo = CLASSES[l_i];
      for(l_j = (l_uo.length-1); l_j >= 0; l_j--)
        {
        l_op         = l_uo[l_j];
        l_op.m_class = l_uo;
        l_op.m_id    = create_id(l_i, l_j);
        }
      }
    }
  
/**
 * Mutate the operation.
 */

  private static  final Mutator<Expression, UnaryExpression>
    MUTATE_OPERATION = new Mutator<Expression, UnaryExpression>()
    {
/**
 * Mutate an existing instance of the genotype.
 * @param p_source        The source instance.
 * @param p_context       The (calling) context to be used.
 * @param p_is_decisional <code>==DECISIONAL_EXPR</code> if the expression
 *                        is decisional,
 *                        <code>==CALCULATIVE_EXPR</code> if the expression
 *                        is calculative.
 * @param p_memory_size   The memory size currently available.
 * @return The randomly mutated copy of the source or <code>p_source</code>
 *         itself if it cannot be mutated in any way.
 */

    @Override
    protected Expression  mutate(final  UnaryExpression   p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      UnaryOperation    l_op, l_oop;
      UnaryOperation[]  l_ops;
      Expression        l_expr;
      Randomizer        l_r;

      l_r    = p_context.get_randomizer();
      l_expr = p_source.get_sub();
      l_oop  = p_source.get_operation();
      l_ops  = l_oop.m_class;

      if(l_ops.length <= 1) return p_source;

main:
      for(;;)
        {
        do
          {
          l_op   = l_ops[l_r.nextInt(l_ops.length)];
          } while(l_op == l_oop);

        if((l_expr instanceof UnaryExpression) &&
            (((UnaryExpression)l_expr).get_operation() == l_op))
          {
          if(l_ops.length <= 2) return p_source;
          continue main;
          }

        return new UnaryExpression(l_op, l_expr);
        }
      }
    };
/**
 * Mutate the sub expression.
 */

  private static  final Mutator<Expression, UnaryExpression>
    MUTATE_SUB = new Mutator<Expression, UnaryExpression>()
    {
/**
 * Mutate an existing instance of the genotype.
 * @param p_source        The source instance.
 * @param p_context       The (calling) context to be used.
 * @param p_is_decisional <code>==DECISIONAL_EXPR</code> if the expression
 *                        is decisional,
 *                        <code>==CALCULATIVE_EXPR</code> if the expression
 *                        is calculative.
 * @param p_memory_size   The memory size currently available.
 * @return The randomly mutated copy of the source or <code>p_source</code>
 *         itself if it cannot be mutated in any way.
 */

      @Override
    protected Expression  mutate(final  UnaryExpression   p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      UnaryOperation    l_op;
      Expression        l_expr;

      l_op   = p_source.get_operation();
      l_expr = p_context.mutate_expression(p_source.get_sub(),
                                            (l_op.m_class == DECISIONAL),
                                            p_memory_size);

      if((l_expr instanceof UnaryExpression) &&
         (((UnaryExpression)l_expr).get_operation() == l_op))
        {
        return p_source;
        }

      return new UnaryExpression(l_op, l_expr);
      }
    
    };
/**
 * Wrap the expression.
 */

  private static  final Mutator<Expression, UnaryExpression>
    MUTATE_WRAP = new Mutator<Expression, UnaryExpression>()
    {
/**
 * Mutate an existing instance of the genotype.
 * @param p_source        The source instance.
 * @param p_context       The (calling) context to be used.
 * @param p_is_decisional <code>==DECISIONAL_EXPR</code> if the expression
 *                        is decisional,
 *                        <code>==CALCULATIVE_EXPR</code> if the expression
 *                        is calculative.
 * @param p_memory_size   The memory size currently available.
 * @return The randomly mutated copy of the source or <code>p_source</code>
 *         itself if it cannot be mutated in any way.
 */

    @Override
    protected Expression  mutate(final  UnaryExpression   p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      return p_context.wrap_expression(p_source,
                      (p_source.get_operation().m_class == DECISIONAL),
                      p_memory_size);
      }
    };
/**
 * Lift the sub-expression.
 */

  private static  final Mutator<Expression, UnaryExpression>
    MUTATE_LIFT = new Mutator<Expression, UnaryExpression>()
    {
/**
 * Mutate an existing instance of the genotype.
 * @param p_source        The source instance.
 * @param p_context       The (calling) context to be used.
 * @param p_is_decisional <code>==DECISIONAL_EXPR</code> if the expression
 *                        is decisional,
 *                        <code>==CALCULATIVE_EXPR</code> if the expression
 *                        is calculative.
 * @param p_memory_size   The memory size currently available.
 * @return The randomly mutated copy of the source or <code>p_source</code>
 *         itself if it cannot be mutated in any way.
 */

    @Override
    protected Expression  mutate(final  UnaryExpression   p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      return p_source.get_sub();
      }
    };


/**
 * The possible mutators of the unary expression.
 */

  private static  final Mutator<Expression, UnaryExpression>[] MUTATORS =
          Arrays.create(MUTATE_OPERATION, MUTATE_LIFT, MUTATE_SUB,
                         MUTATE_WRAP);
/**
 * The frequencies at which the mutations are selected.
 */

  private static  final double[]  FREQUENCIES = {2.0d, 8.0d,
                                                 1.0d, 1.0d};
/**
 * The shared singleton handler instance.
 */

  static  final WrapableExpressionHandler<Expression>  INSTANCE   =
                            Typesafe.cast(new UnaryExpressionHandler());
  
/**
 * Create a new constant handler.
 */

    private UnaryExpressionHandler()
      {
      super(MUTATORS, FREQUENCIES);
      }
/**
 * Create a new, random instance of the genotype.
 * @param p_context     The program context to be used.
 * @param p_decision    <code>true</code> if and only if the expression
 *                      required is a decisional expression.
 *                      <code>false</code> if it is an arithmetical
 *                      expression.
 * @param p_source      The source expression to be wrapped.
 * @param p_memory_size   The memory size currently available.
 * @return  The random genotype instance.
 */

  @Override
  protected  final  Expression  wrap  (final ProgramContext  p_context,
                                       final boolean         p_decision,
                                       final int             p_memory_size,
                                       final Expression      p_source)
    {
    UnaryOperation[] l_ex3;
    UnaryOperation   l_op, l_oop;
    Randomizer       l_r;

    l_ex3 = (p_decision ? DECISIONAL : CALCULATIVE);

    if(p_source instanceof UnaryExpression)
      {
      if(l_ex3.length <= 1) return p_source;
      l_oop = ((UnaryExpression)p_source).get_operation();
      }
    else
      {
      l_oop = null;
      }

    l_r = p_context.get_randomizer();    
    do
      {
      l_op = l_ex3[l_r.nextInt(l_ex3.length)];
      } while(l_op == l_oop);

    return new UnaryExpression(l_op, p_source);
    }

/**
 * Create a new, random instance of the genotype.
 * @param p_context     The (calling) context to be used.
 * @param p_decision    <code>true</code> if and only if the expression
 *                      required is a decisional expression.
 *                      <code>false</code> if it is an arithmetical
 *                      expression.
 * @param p_memory_size The memory size currently available.
 *
 * @return  The random genotype instance.
 */

  @Override
  protected  final  Expression  create(final ProgramContext  p_context,
                                       final boolean         p_decision,
                                       final int             p_memory_size)
    {
    UnaryOperation    l_op;
    UnaryOperation[]  l_c;
    Expression        l_expr;

    l_c    = (p_decision ? DECISIONAL : CALCULATIVE);
    l_op   = l_c[p_context.get_randomizer().nextInt(l_c.length)];
    l_expr = p_context.create_expression(p_decision, true,
                                          p_memory_size);

    if( (l_expr instanceof UnaryExpression) &&
        (((UnaryExpression)l_expr).get_operation() == l_op) )
      {
      return (((UnaryExpression)l_expr).get_sub());
      }

    return new UnaryExpression(l_op, l_expr);
    }


/**
 * This method returns an optimized version of the source expression,
 * or the source expression itself if it cannot be optimized.
 * @param p_source  The source expression.
 * @return  An optimized version of the source expression,
 *          or the source expression itself if it cannot be optimized.
 */

  @Override
  public  final Expression  optimize   (final UnaryExpression p_source)
    {
    Expression        l_ex, l_sub;
    UnaryExpression   l_ue;
    UnaryOperation    l_op;
    BinaryExpression  l_b;
    BinaryOperation   l_bb;
    
    l_sub = p_source.get_sub();
    l_op  = p_source.get_operation();
    l_ex  = l_sub.optimize();
    
    if(l_ex instanceof Constant)
      {
      return Constant.create_constant(
                        l_op.execute(((Constant)l_ex).get_value()) );
      }
   
    if(l_ex instanceof UnaryExpression)
      {
      l_ue = ((UnaryExpression)(l_ex));
      if(l_ue.get_operation() == l_op)
        {
        return l_ue.get_sub();
        }
      }
    
    if(l_op == UnaryExpression.LNOT)
      {
      if(l_ex instanceof BinaryExpression)
        {
        l_b  = ((BinaryExpression)l_ex);
        l_bb = l_b.get_operation().get_inverse();
        if(l_bb != null)
          {
          return new BinaryExpression(l_bb, l_b.get_sub_1(),
                                            l_b.get_sub_2()).optimize();
          }
        }
      }
    
    if((l_ex != null) && (l_ex != l_sub))
      {
      p_source.init(l_ex);
      }
    
    return p_source;
    }


/**
 * Checks wether this instruction handler is able to produce decisional or
 * non-decisional expressions.
 * @param p_decision    <code>true</code> if and only if the expressions
 *                      required are a decisional expression.
 *                      <code>false</code> if they are arithmetical
 *                      expression.
 *
 * @return  The random genotype instance.
 */

  @Override
  public final boolean can_produce (final boolean p_decision)
    {
    return p_decision; //With that statement, all calculative unary
                       //expressions become disabled!
    }

/**
 * If this expression referes to a memory cell (like the ReadDirect-expression
 * does), this method should return its refered memory cell. If the
 * expression contains one or more such sub-expressions, it should return
 * a randomly selected memory cell of them.
 * @param p_source  The source object.
 * @param p_random  The randomizer.
 * @return  A memory cell refered by this expression, or <code>-1</code>
 *          if this expression does not refere any memory cell.
 */

  @Override
  public  final int  get_internal_address(final UnaryExpression p_source,
                                          final Randomizer      p_random)
    {
    Expression  l_e;

    l_e = p_source.get_sub();
    return l_e.get_handler().get_internal_address(l_e, p_random);
    }
  

/**
 * Calculate an operation id for a operation.
 * @param p_class The operation's class;
 * @param p_op    The operation's id.
 * @return  The operation identifier.
 */

  private static  final int create_id   (final int p_class,
                                         final int p_op)
    {
    return ((p_class << 16) | (p_op));
    }

/**
 * Returns the unary operation that matches the given id.
 * @param p_id    The id to find the operation to.
 * @return The binary operation that has exactly this id.
 */

  static  final UnaryOperation get_op  (final int p_id)
    {
    return CLASSES[(p_id >>> 16)][p_id & 0xffff];
    }
  }

File Information:

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