Logo
Distributed Genetic Programming Framework
print print

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

Here you can find all the information about the file org.dgpf.gp.automaton.expressions.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-02-07 06:14:31
 * Original Filename: org.dgpf.automaton.expressions.BinaryExpressionHandler.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.search.Mutator;
import org.dgpf.gp.automaton.search.ProgramContext;
import org.dgpf.gp.automaton.search.WrapableExpressionHandler;
import org.dgpf.search.api.SearchUtils;
import org.sfc.collections.Arrays;
import org.sfc.math.stochastic.Randomizer;
import org.sfc.utils.Typesafe;

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

final class    BinaryExpressionHandler
      extends  WrapableExpressionHandler<BinaryExpression>
  {

/**
 * The randomized operation array.
 */

  static  final BinaryOperation[] DECISIONAL  = new BinaryOperation[]
      {BinaryExpression.EQ,
       BinaryExpression.NEQ,
       BinaryExpression.LT,
       BinaryExpression.LTE,
       BinaryExpression.GT,
       BinaryExpression.GTE,
       BinaryExpression.LAND,
       BinaryExpression.LOR};

/**
 * The randomized operation array.
 */

  static  final double[]          DWEIGHTS    = new double[]
      {1.0d, 1.0d, 1.0d, 0.5d, 1.0d, 0.5d, 1.0d, 1.0d};

/**
 * The randomized operation array.
 */

  static  final BinaryOperation[] CALCULATIVE = new BinaryOperation[]
      {BinaryExpression.ADD,
       BinaryExpression.SUB,
       BinaryExpression.MUL,
       BinaryExpression.DIV,
       BinaryExpression.MOD,
       BinaryExpression.BAND,
       BinaryExpression.BOR,
       BinaryExpression.BXOR};

/**
 * The randomized operation array.
 */

  static  final double[]          CWEIGHTS    = new double[]
      {5.0d, 4.0d, 2.7d, 2.5d, 2.0d, 1.0d, 1.2d, 1.0d};



/**
 * The operation's classes.
 */

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


  static
    {
          int                 l_y, l_c;
          BinaryOperation     l_op;
          BinaryOperation[]   l_o;
          double[]            l_w;
    final double[][]          l_ws = new double[][] {DWEIGHTS, CWEIGHTS};
          double              l_s;

    for(l_c = (CLASSES.length-1); l_c >= 0; l_c--)
      {
      l_s = 0.0d;
      l_o = CLASSES[l_c];
      l_w = l_ws[l_c];


      for(l_y = 0; l_y < l_w.length; l_y++)
        {
        l_s     += l_w[l_y];
        l_w[l_y] = l_s;
        }
      l_s = (1.0d / l_s);

      for(l_y = (l_o.length-1); l_y >= 0; l_y--)
        {
        l_op         = l_o[l_y];
        l_op.m_class = l_o;
        l_op.m_id    = create_id(l_c, l_y);
        l_w[l_y]    *= l_s;
        }

      l_w[l_w.length-1] = Double.MAX_VALUE;
      }
    }
  
/**
 * Chane the expression's operation.
 */

  private static  final Mutator<Expression, BinaryExpression>
    MUTATE_OPERATION = new Mutator<Expression, BinaryExpression>()
    {

/**
 * Obtain a binary operation that is likely the one mentioned.
 * @param p_bo      The binary operation.
 * @param p_random  The randomizer.
 * @return  Another binary operation which is somehow like the other one.
 */

    private final BinaryOperation get_likely(final BinaryOperation p_bo,
                                             final Randomizer p_random)
      {
      final int l_choice;

      l_choice = p_random.nextInt(1000);

      if(p_bo == BinaryExpression.BXOR)
        {
        if(l_choice < 266) return BinaryExpression.BOR;
        if(l_choice < 462) return BinaryExpression.DIV;
        if(l_choice < 619) return BinaryExpression.MOD;
        if(l_choice < 752) return BinaryExpression.ADD;
        if(l_choice < 882) return BinaryExpression.SUB;
        if(l_choice < 987) return BinaryExpression.BAND;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.BOR)
        {
        if(l_choice < 198) return BinaryExpression.BXOR;
        if(l_choice < 396) return BinaryExpression.ADD;
        if(l_choice < 588) return BinaryExpression.DIV;
        if(l_choice < 775) return BinaryExpression.MOD;
        if(l_choice < 896) return BinaryExpression.BAND;
        if(l_choice < 991) return BinaryExpression.SUB;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.BAND)
        {
        if(l_choice < 240) return BinaryExpression.MOD;
        if(l_choice < 447) return BinaryExpression.ADD;
        if(l_choice < 635) return BinaryExpression.DIV;
        if(l_choice < 780) return BinaryExpression.BOR;
        if(l_choice < 896) return BinaryExpression.SUB;
        if(l_choice < 990) return BinaryExpression.BXOR;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.MOD)
        {
        if(l_choice < 261) return BinaryExpression.DIV;
        if(l_choice < 455) return BinaryExpression.BAND;
        if(l_choice < 637) return BinaryExpression.BOR;
        if(l_choice < 758) return BinaryExpression.SUB;
        if(l_choice < 878) return BinaryExpression.ADD;
        if(l_choice < 992) return BinaryExpression.BXOR;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.DIV)
        {
        if(l_choice < 267) return BinaryExpression.MOD;
        if(l_choice < 456) return BinaryExpression.BOR;
        if(l_choice < 611) return BinaryExpression.BAND;
        if(l_choice < 756) return BinaryExpression.BXOR;
        if(l_choice < 873) return BinaryExpression.SUB;
        if(l_choice < 991) return BinaryExpression.ADD;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.MUL)
        {
        if(l_choice < 151) return BinaryExpression.BXOR;
        if(l_choice < 297) return BinaryExpression.BOR;
        if(l_choice < 440) return BinaryExpression.DIV;
        if(l_choice < 581) return BinaryExpression.MOD;
        if(l_choice < 722) return BinaryExpression.SUB;
        if(l_choice < 863) return BinaryExpression.ADD;
        return BinaryExpression.BAND;
        }

      if(p_bo == BinaryExpression.SUB)
        {
        if(l_choice < 202) return BinaryExpression.MOD;
        if(l_choice < 394) return BinaryExpression.DIV;
        if(l_choice < 551) return BinaryExpression.BXOR;
        if(l_choice < 706) return BinaryExpression.BAND;
        if(l_choice < 860) return BinaryExpression.BOR;
        if(l_choice < 986) return BinaryExpression.ADD;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.ADD)
        {
        if(l_choice < 248) return BinaryExpression.BOR;
        if(l_choice < 463) return BinaryExpression.BAND;
        if(l_choice < 619) return BinaryExpression.MOD;
        if(l_choice < 768) return BinaryExpression.DIV;
        if(l_choice < 892) return BinaryExpression.BXOR;
        if(l_choice < 989) return BinaryExpression.SUB;
        return BinaryExpression.MUL;
        }

      if(p_bo == BinaryExpression.LOR)
        {
        if(l_choice < 525) return BinaryExpression.NEQ;
        if(l_choice < 787) return BinaryExpression.LAND;
        if(l_choice < 836) return BinaryExpression.LTE;
        if(l_choice < 885) return BinaryExpression.GTE;
        if(l_choice < 930) return BinaryExpression.LT;
        if(l_choice < 975) return BinaryExpression.GT;
        return BinaryExpression.EQ;
        }

      if(p_bo == BinaryExpression.LAND)
        {
        if(l_choice < 402) return BinaryExpression.LOR;
        if(l_choice < 669) return BinaryExpression.NEQ;
        if(l_choice < 745) return BinaryExpression.GTE;
        if(l_choice < 820) return BinaryExpression.LTE;
        if(l_choice < 889) return BinaryExpression.GT;
        if(l_choice < 958) return BinaryExpression.LT;
        return BinaryExpression.EQ;
        }

      if(p_bo == BinaryExpression.GTE)
        {
        if(l_choice < 674) return BinaryExpression.GT;
        if(l_choice < 741) return BinaryExpression.EQ;
        if(l_choice < 807) return BinaryExpression.LOR;
        if(l_choice < 874) return BinaryExpression.LAND;
        if(l_choice < 935) return BinaryExpression.NEQ;
        if(l_choice < 968) return BinaryExpression.LTE;
        return BinaryExpression.LT;
        }

      if(p_bo == BinaryExpression.GT)
        {
        if(l_choice < 682) return BinaryExpression.GTE;
        if(l_choice < 749) return BinaryExpression.NEQ;
        if(l_choice < 811) return BinaryExpression.LOR;
        if(l_choice < 873) return BinaryExpression.LAND;
        if(l_choice < 934) return BinaryExpression.EQ;
        if(l_choice < 968) return BinaryExpression.LT;
        return BinaryExpression.LTE;
        }

      if(p_bo == BinaryExpression.LTE)
        {
        if(l_choice < 675) return BinaryExpression.LT;
        if(l_choice < 742) return BinaryExpression.EQ;
        if(l_choice < 808) return BinaryExpression.LAND;
        if(l_choice < 874) return BinaryExpression.LOR;
        if(l_choice < 935) return BinaryExpression.NEQ;
        if(l_choice < 968) return BinaryExpression.GTE;
        return BinaryExpression.GT;
        }

      if(p_bo == BinaryExpression.LT)
        {
        if(l_choice < 681) return BinaryExpression.LTE;
        if(l_choice < 749) return BinaryExpression.NEQ;
        if(l_choice < 811) return BinaryExpression.LOR;
        if(l_choice < 872) return BinaryExpression.LAND;
        if(l_choice < 934) return BinaryExpression.EQ;
        if(l_choice < 968) return BinaryExpression.GT;
        return BinaryExpression.GTE;
        }

      if(p_bo == BinaryExpression.NEQ)
        {
        if(l_choice < 576) return BinaryExpression.LOR;
        if(l_choice < 767) return BinaryExpression.LAND;
        if(l_choice < 821) return BinaryExpression.LT;
        if(l_choice < 876) return BinaryExpression.GT;
        if(l_choice < 925) return BinaryExpression.LTE;
        if(l_choice < 974) return BinaryExpression.GTE;
        return BinaryExpression.EQ;
        }

      if(p_bo == BinaryExpression.EQ)
        {
        if(l_choice < 187) return BinaryExpression.GTE;
        if(l_choice < 374) return BinaryExpression.LTE;
        if(l_choice < 544) return BinaryExpression.GT;
        if(l_choice < 715) return BinaryExpression.LT;
        if(l_choice < 818) return BinaryExpression.LAND;
        if(l_choice < 911) return BinaryExpression.LOR;
        return BinaryExpression.NEQ;
        }

      throw new RuntimeException();
      }

/**
 * 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  BinaryExpression  p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      BinaryOperation[] l_ops;
      BinaryOperation   l_op, l_oop;
      Randomizer        l_r;
      
      l_r = p_context.get_randomizer();
      
      l_oop = p_source.get_operation();
      if(l_r.nextInt(10) > 0)
        {
        l_op = this.get_likely(l_oop, l_r);
        }
      else
        {
        do
          {
          l_ops = l_oop.m_class;
          l_op  = l_ops[SearchUtils.random_index( (l_ops == DECISIONAL) ?
                        DWEIGHTS : CWEIGHTS, l_r.nextDouble())];
          } while(l_op == l_oop);
        }

      return new BinaryExpression(l_op, p_source.get_sub_1(),
                                        p_source.get_sub_2());
      }
    };

/**
 * Mutate a BinaryExpression.SUB-expression.
 */

  private static  final Mutator<Expression, BinaryExpression>
  MUTATE_SUB = new Mutator<Expression, BinaryExpression>()
    {
/**
 * 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  BinaryExpression  p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      BinaryOperation l_oop;
      Expression      l_sub1, l_sub2;
      
      l_oop   = p_source.get_operation();
      l_sub1  = p_source.get_sub_1();
      l_sub2  = p_source.get_sub_2();
      
      return p_context.get_randomizer().nextBoolean()
                ? new BinaryExpression(l_oop,
                    p_context.mutate_expression( l_sub1,
                    (l_oop.m_class == DECISIONAL),
                    p_memory_size), l_sub2)
                : new BinaryExpression(l_oop,
                    l_sub1,
                    p_context.mutate_expression( l_sub2, 
                    (l_oop.m_class == DECISIONAL),
                         p_memory_size));
      }
    };


/**
 * Wrap the whole expression into another one.
 */

  private static  final Mutator<Expression, BinaryExpression>
  MUTATE_WRAP = new Mutator<Expression, BinaryExpression>()
    {
/**
 * 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  BinaryExpression  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 first BinaryExpression.SUB-expression.
 */

  private static  final Mutator<Expression, BinaryExpression>
  MUTATE_LIFT = new Mutator<Expression, BinaryExpression>()
    {
/**
 * 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  BinaryExpression  p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      return (p_context.get_randomizer().nextBoolean() ? p_source.get_sub_1()
                                                   : p_source.get_sub_2());
      }
    };

/**
 * Exchange the two BinaryExpression.SUB-expressions.
 */

  private static  final Mutator<Expression, BinaryExpression>
  MUTATE_EXCHG = new Mutator<Expression, BinaryExpression>()
    {
/**
 * 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  BinaryExpression  p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      if(p_source.get_operation().is_cummutative()) return p_source;
      return new BinaryExpression(p_source.get_operation(),
                    p_source.get_sub_2(), p_source.get_sub_1());
      }
    };
    
/**
 * Replace one of the two BinaryExpression.SUB-expressions.
 */

  private static  final Mutator<Expression, BinaryExpression>
  MUTATE_REPLACE = new Mutator<Expression, BinaryExpression>()
    {
/**
 * 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  BinaryExpression  p_source,
                                 final  ProgramContext    p_context,
                                 final  int               p_is_decisional,
                                 final  int               p_memory_size)
      {
      boolean     l_b;
      Expression  l_e, l_e2;
      
      l_b = p_context.get_randomizer().nextBoolean();
      l_e = (l_b ? p_source.get_sub_1() : p_source.get_sub_2());
      
      do
        {
        l_e2 = p_context.create_expression(
                                      (p_is_decisional == DECISIONAL_EXPR),
                                       true, p_memory_size);
        } while(l_e.equals(l_e2));
            
      return new BinaryExpression(p_source.get_operation(),
                    l_b ? l_e2 : p_source.get_sub_1(),
                    l_b ? p_source.get_sub_2() : l_e);
      }
    };

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

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

  private static  final double[]  FREQUENCIES = {3.0d, 10.0d, 
        (UnaryExpressionHandler.INSTANCE.can_produce(false) ? 2.5d : 3.5d),
                                                   1.0d, 0.1d, 5.0d};

    
/**
 * The shared singleton handler instance.
 */

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

  private BinaryExpressionHandler()
    {
    super(MUTATORS, FREQUENCIES);
    }

/**
 * Create a new, random instance of the genotype.
 * @param p_context     The program context.
 * @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)
    {
    Expression           l_ex;
    BinaryOperation[]    l_ex2;
    boolean              l_b;
    Randomizer           l_r;

    l_r   = p_context.get_randomizer();
    l_ex  = p_context.create_expression(p_decision, true,
                                         p_memory_size);
    l_ex2 = (p_decision ? DECISIONAL : CALCULATIVE);
    l_b   = l_r.nextBoolean();

    return new BinaryExpression(l_ex2[SearchUtils.random_index(
                                      p_decision ? DWEIGHTS : CWEIGHTS,
                                          l_r.nextDouble())],
                                (l_b ? l_ex     : p_source),
                                (l_b ? p_source : l_ex));
    }

/**
 * 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)
    {
    final BinaryOperation[] l_ops;

    l_ops     = (p_decision ? DECISIONAL : CALCULATIVE);

    return new BinaryExpression(
              l_ops[SearchUtils.random_index(
                      (p_decision ? DWEIGHTS : CWEIGHTS),
                          p_context.get_randomizer().nextDouble())],
                   p_context.create_expression(p_decision,
                                                true, p_memory_size),
                   p_context.create_expression(p_decision,
                                                true, p_memory_size));
    }


/**
 * 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 BinaryExpression p_source)
    {
    Expression  l_ex1, l_ex2;
    boolean     l_b1, l_b2;
    
    l_ex1 = p_source.get_sub_1().optimize();
    l_ex2 = p_source.get_sub_2().optimize();
    
    l_b1 = (l_ex1 instanceof Constant);
    l_b2 = (l_ex2 instanceof Constant);
    
    return p_source.get_operation().do_optimize(p_source,
                  l_b1, (l_b1 ? ((Constant)l_ex1).get_value() : 0),
                  l_b2, (l_b2 ? ((Constant)l_ex2).get_value() : 0),
                                           l_ex1, l_ex2);
    }

/**
 * 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 true;
    }

/**
 * 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 BinaryExpression.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 BinaryExpression p_source,
                                         final Randomizer       p_random)
    {
    boolean     l_b;
    int         l_i;
    Expression  l_ex;

    l_b = p_random.nextBoolean();

    if(l_b) l_ex = p_source.get_sub_1();
    else    l_ex = p_source.get_sub_2();

    l_i = l_ex.get_handler().get_internal_address(l_ex, p_random);
    if(l_i >= 0) return l_i;

    if(l_b) l_ex = p_source.get_sub_2();
    else    l_ex = p_source.get_sub_1();

    return l_ex.get_handler().get_internal_address(l_ex, 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 binary 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 BinaryOperation get_op  (final int p_id)
    {
    return CLASSES[(p_id >>> 16)][p_id & 0xffff];
    }
  
/**
 * Ensure the the binary expression presented is a conditional expression.
 * @param p_be  The binary expression.
 * @return A conditional expression with the same semantics as
 *         <code>p_be</code>.
 */

  static final Expression conditionalize(final BinaryExpression p_be)
    {
    final BinaryOperation l_op;
    final Expression      l_e1, l_e2;
    
    l_op = p_be.get_operation();
    if(l_op.m_class == DECISIONAL) return p_be;
    
    l_e1 = p_be.get_sub_1();
    l_e2 = p_be.get_sub_2();
    
    
    if(l_op == BinaryExpression.SUB)
      {
      return new BinaryExpression(BinaryExpression.NEQ, l_e1, l_e2);
      }    
    
    if(l_op == BinaryExpression.BXOR)
      {
      return new BinaryExpression(BinaryExpression.NEQ, l_e1, l_e2);
      }  
      
    return p_be;
    }
  }

File Information:

file name:BinaryExpressionHandler.java
package:org.dgpf.gp.automaton.expressions
qualified name:org.dgpf.gp.automaton.expressions.BinaryExpressionHandler.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/automaton/expressions/BinaryExpressionHandler.java
size:27.921 KB (28592 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:57:38 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:57:38 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo