Logo
Distributed Genetic Programming Framework
print print

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

Here you can find all the information about the file org.dgpf.gp.automaton.expressions.BinaryExpression.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2005 Thomas Weise
 *
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-12-28 06:09:33
 * Original Filename: org.dgpf.automaton.expressions.BinaryExpression.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 java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;

import org.dgpf.gp.automaton.base.Automaton;
import org.dgpf.gp.automaton.base.Expression;
import org.dgpf.gp.automaton.search.ExpressionHandler;



/**
 * This class can be used to create binary expressions.
 *
 * @author Thomas Weise
 */

public  final class BinaryExpression extends Expression
  {
/**
 * The serial version uid.
 */

  private static  final long            serialVersionUID  = 1;


/**
 * The + operation.
 */

  public  static  final BinaryOperation ADD = new Add();
/**
 * The - operation.
 */

  public  static  final BinaryOperation SUB = new Sub();
/**
 * The * operation.
 */

  public  static  final BinaryOperation MUL = new Mul();
/**
 * The / operation.
 */

  public  static  final BinaryOperation DIV = new Div();
/**
 * The % operation.
 */

  public  static  final BinaryOperation MOD = new Mod();
/**
 * The LT operation.
 */

  public  static  final BinaryOperation LT  = new Lt();
/**
 * The LTE operation.
 */

  public  static  final BinaryOperation LTE = new Lte();
/**
 * The GT operation.
 */

  public  static  final BinaryOperation GT  = new Gt();
/**
 * The GTE operation.
 */

  public  static  final BinaryOperation GTE = new Gte();
/**
 * The EQ operation.
 */

  public  static  final BinaryOperation EQ  = new Eq();
/**
 * The NEQ operation.
 */

  public  static  final BinaryOperation NEQ = new Neq();
/**
 * The & operation.
 */

  public  static  final BinaryOperation BAND  = new BAnd();
/**
 * The | operation.
 */

  public  static  final BinaryOperation BOR   = new BOr();
/**
 * The ^ operation.
 */

  public  static  final BinaryOperation BXOR  = new BXor();
/**
 * The && operation.
 */

  public  static  final BinaryOperation LAND  = new LAnd();
/**
 * The || operation.
 */

  public  static  final BinaryOperation LOR   = new LOr ();

  
  static
    {
    ADD.m_inverse = SUB;
    SUB.m_inverse = ADD;
    MUL.m_inverse = DIV;
    DIV.m_inverse = MUL;
    LT.m_inverse  = GTE;
    LTE.m_inverse = GT;
    GT.m_inverse  = LTE;
    GTE.m_inverse = LT;
    EQ.m_inverse  = NEQ;
    NEQ.m_inverse = EQ;
    }
  
/**
 * The handler used by this class.
 */

  public  static  final ExpressionHandler<Expression> HANDLER =
                                         BinaryExpressionHandler.INSTANCE;

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

  private               Expression         m_sub_1        ;
/**
 * The second sub-expression.
 */

  private               Expression         m_sub_2        ;
/**
 * The binary operation to be performed by this expression.
 */

  private transient     BinaryOperation    m_operation    ;
/**
 * The internal operation id.
 */

  private               int                m_op ;


  
/**
 * Create a new binary expression.
 * @param p_sub_1     The first sub-expression.
 * @param p_sub_2     The second sub-expression.
 * @param p_operation The binary operation to be performed by this
 *                    expression.
 */

  public  BinaryExpression(final BinaryOperation  p_operation,
                           final Expression       p_sub_1,
                           final Expression       p_sub_2)
    {
    super(1 + p_sub_1.get_complexity() + p_sub_2.get_complexity());

    this.m_sub_1        = p_sub_1;
    this.m_sub_2        = p_sub_2;
    this.m_operation    = p_operation;
    this.m_op           = p_operation.m_id;
    }

/**
 * Initialize this binary expression.
 * @param p_sub_1     The first sub-expression.
 * @param p_sub_2     The second sub-expression.
 */

  final void  init  (final Expression       p_sub_1,
                     final Expression       p_sub_2)
    {    
    this.m_sub_1        = p_sub_1;
    this.m_sub_2        = p_sub_2;
    this.set_ticks(1 + p_sub_1.get_complexity() + p_sub_2.get_complexity());
    }
  
/**
 * Obtain the operation which is performed by this expression.
 * @return The operation which is performed by this expression.
 */

  public  final BinaryOperation get_operation ()
    {
    return this.m_operation;
    }
  
/**
 * Checks wether this expression has side effects, returns <code>true</code>
 * if so.
 * @return  <code>true</code> if and only if this expression has side
 *          effects.
 */

  @Override
  public  final boolean has_side_effect ()
    {
    return (this.m_sub_1.has_side_effect() ||
            this.m_sub_2.has_side_effect());
    }
  
/**
 * Obtain the first sub-expression.
 * @return The first  sub-expression.
 */

  public  final Expression      get_sub_1 ()
    {
    return this.m_sub_1;
    }
  
/**
 * Ensure that this expression is boolean.
 * @return  A boolean expression representing this one.
 */

  public  final Expression  conditionalize()
    {
    return BinaryExpressionHandler.conditionalize(this);
    }
  
/**
 * Obtain the second sub-expression.
 * @return The second sub-expression.
 */

  public  final Expression      get_sub_2 ()
    {
    return this.m_sub_2;
    }
  
  
/**
 * Obtain the count of memory cells this item needs.
 * @return  The count of memory cells this item needs.
 */

  @Override
  public  final int   get_memory_size ()
    {
    return Math.max(this.m_sub_1.get_memory_size(),
                    this.m_sub_2.get_memory_size());
    }
  
/**
 * The recursive check to determine if there are no side-effect sub-
 * expressions.
 * @param p_e  The expression.
 * @return <code>true</code> if and only if there are only non-sideeffect
 *         sub-expressions.  
 */

  final static  boolean eq  (final Expression p_e)
    {
    if(p_e instanceof BinaryExpression)
      {
      return  ( eq(((BinaryExpression)p_e).m_sub_1) &&
                eq(((BinaryExpression)p_e).m_sub_2) );
      }
    
    if(p_e instanceof UnaryExpression)
      {
      return eq(((UnaryExpression)p_e).get_sub());
      }
    
    return ((p_e instanceof Constant) || (p_e instanceof Read));
    }
  
/**
 * Checks wether this object is equal to another object.
 * @param p_object  The object to compare with.
 * @return  <code>true</code> if and only if the two objects are exactly
 *          equal.
 */

  @Override
  public  final boolean equals  (final Object p_object)
    {
    BinaryExpression l_be;
    BinaryOperation  l_op;
    Expression       l_ex;
    UnaryExpression  l_u;
    
    if(p_object == thisreturn true;
    
    if(p_object instanceof BinaryExpression)
      {
      l_be = ((BinaryExpression)p_object);
      l_op = l_be.m_operation;
      
      if(l_be.m_op == this.m_op)
        {
        if(l_be.m_sub_1.equals(this.m_sub_1))
          {
          return l_be.m_sub_2.equals(this.m_sub_2);
          }
        
        if( (l_op.is_cummutative()) && (l_be.m_sub_1.equals(this.m_sub_2)))
          {
          return l_be.m_sub_2.equals(this.m_sub_1);
          }                
        }      
      }
    
    if(this.m_op == EQ.m_id)
      {
      l_ex = this.m_sub_1;
      if( (l_ex instanceof Constant) &&
          (((Constant)l_ex).get_value() == 0))
        {
        if(p_object instanceof UnaryExpression)
          {
          l_u = ((UnaryExpression)p_object);
          if(l_u.get_operation() == UnaryExpression.LNOT)
            {
            return this.m_sub_2.equals(l_u.get_sub());
            }
          }
        }
      
      l_ex = this.m_sub_2;
      if( (l_ex instanceof Constant) &&
          (((Constant)l_ex).get_value() == 0))
        {
        if(p_object instanceof UnaryExpression)
          {
          l_u = ((UnaryExpression)p_object);
          if(l_u.get_operation() == UnaryExpression.LNOT)
            {
            return this.m_sub_1.equals(l_u.get_sub());
            }
          }
        }
      }
    
    if(this.m_op == NEQ.m_id)
      {
      l_ex = this.m_sub_1;
      if( (l_ex instanceof Constant) &&
          (((Constant)l_ex).get_value() == 0))
        {
        return this.m_sub_2.equals(p_object);
        }
      
      l_ex = this.m_sub_2;
      if( (l_ex instanceof Constant) &&
          (((Constant)l_ex).get_value() == 0))
        {
        return this.m_sub_1.equals(p_object);
        }
      }
    
    return false;
    }
  


/**
 * Reconstitute the <code>ArrayList</code> instance from a stream (that is,
 * deserialize it).
 * @param p_s The input stream.
 * @throws  IOException If something io-like went wrong.
 * @throws  ClassNotFoundException  If a needed class could not be found.
 */

  private final void readObject(final ObjectInputStream p_s)
        throws IOException, ClassNotFoundException
    {
    p_s.defaultReadObject();
    this.m_operation = BinaryExpressionHandler.get_op(this.m_op);
    }

/**
 * This method is called when the construct is executed. It performs the
 * work of the construct.
 * @param p_automate    The automate it is invoked on.
 * @return  The return value of the construct.
 */

  @Override
  public  final int   execute (final Automaton p_automate)
    {
    return this.m_operation.execute(this.m_sub_1, this.m_sub_2, p_automate);
    }



/**
 * Store this objects content into a string builder.
 * @param p_sb  The string builder to store stuff into.
 */

  @Override
  public  final void  to_string (final StringBuilder p_sb)
    {
    p_sb.append('(');
    this.m_sub_1.to_string(p_sb);
    p_sb.append(this.m_operation.m_op);
    this.m_sub_2.to_string(p_sb);
    p_sb.append(')');
    }

/**
 * Returns the genetic handler of the code construct.
 * @return The genetic handler of the code construct.
 */

  @Override
  public final ExpressionHandler<Expression> get_handler ()
    {
    return HANDLER;
    }


/**
 * The internal operation class.
 *
 * @author Thomas Weise
 */

  public  static  abstract  class BinaryOperation implements  Serializable
    {
/**
 * The operation string.
 */

            final char[]              m_op ;
/**
 * The operational class.
 */

                  BinaryOperation[]   m_class;
/**
 * The id of the operation.
 */

                  int                 m_id  ;
/**
 * <code>true</code> if and only if the operation is commutative, meaning
 * its operands can be swapped without changing its result. 
 */

    private final boolean             m_is_commutative ;
/**
 * Returns the inverse operation to this one. The returned value might be
 * <code>null</code> if no inverse operation exists.
 */

                  BinaryOperation     m_inverse ;
    
/**
 * Create a new operation.
 * @param p_operation       The operation string.
 * @param p_is_commutative  <code>true</code> if and only if the operation
 *                          is commutative, meaning its operands can be
 *                          swapped without changing its result.
 */

    BinaryOperation (final char[]           p_operation,
                     final boolean          p_is_commutative)
      {
      super();
      this.m_op             = p_operation;
      this.m_is_commutative = p_is_commutative;
      }

/**
 * Returns the inverse operation to this one. The returned value might be
 * <code>null</code> if no inverse operation exists.
 * @return The inverse operation to this one.
 */

    public  final BinaryOperation get_inverse ()
      {
      return this.m_inverse;
      }
    
/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    abstract  int   execute (final Expression p_param_1,
                             final Expression p_param_2,
                             final Automaton  p_automate);



/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    abstract  Expression  do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2);

/**
 * Clone this object.
 * @return  A perfect copy of this object.
 */

    @Override
    public  Object  clone ()
      {
      try
        {
        return super.clone();
        }
      catch(CloneNotSupportedException l_cnse)
        {
        return this//will never happen.
        }
      }
    
/**
 * Returns <code>true</code> if and only if this binary operation is
 * cummutative.
 * @return <code>true</code> if and only if this binary operation is
 *         cummutative.
 */

    public  final boolean is_cummutative  ()
      {
      return this.m_is_commutative;
      }
    }

/**
 * The add-operation.
 *
 * @author Thomas Weise
 */

  static  final class Add extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long   serialVersionUID = 1;
/**
 * The name of the add operator.
 */

    private static final char[] NAME = new char[] {'+'};
/**
 * Create a new operation.
 */

    Add()
      {
      super(NAME, true);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return p_param_1.execute(p_automate) +
             p_param_2.execute(p_automate);
      }



/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 + p_v2);
      
      if(p_v1c && (p_v1 == 0)) return p_sub2;
      if(p_v2c && (p_v2 == 0)) return p_sub1;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The sub-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Sub extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the sub operator.
 */

    private static final char[] NAME = new char[] {'-'};
/**
 * Create a new operation.
 */

    Sub()
      {
      super(NAME, false);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return p_param_1.execute(p_automate) -
             p_param_2.execute(p_automate);
      }



/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 - p_v2);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1))
                      return Constant.CZERO;
      
      if(p_v2c && (p_v2 == 0)) return p_sub1;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The mul-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Mul extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the mul operator.
 */

    private static final char[] NAME = new char[] {'*'};
/**
 * Create a new operation.
 */

    Mul()
      {
      super(NAME, true);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return p_param_1.execute(p_automate) *
             p_param_2.execute(p_automate);
      }


    


/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 * p_v2);
      
      if(p_v1c && (p_v1 == 0)) return Constant.create_constant(0);
      if(p_v2c && (p_v2 == 0)) return Constant.create_constant(0);
      if(p_v1c && (p_v1 == 1)) return p_sub2;
      if(p_v2c && (p_v2 == 1)) return p_sub1;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The div-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Div extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the div operator.
 */

    private static final char[] NAME = new char[] {'/'};
/**
 * Create a new operation.
 */

    Div()
      {
      super(NAME, false);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      int l_b;


      l_b = p_param_2.execute(p_automate);
      if(l_b == 0) l_b = 1;
      return p_param_1.execute(p_automate) / l_b ;
      }


    

/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v2c && ((p_v2 == 0) || (p_v2 == 1))) return p_sub1;
      
      if(p_v1c && (p_v1 == 0)) return p_sub1;
      
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 / p_v2);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1))
                          return Constant.create_constant(1);
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The modulo-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Mod extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the modulo operator.
 */

    private static final char[] NAME = new char[] {'%'};
/**
 * Create a new operation.
 */

    Mod()
      {
      super(NAME, false);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      int l_b;


      l_b = p_param_2.execute(p_automate);
      if(l_b == 0) return 0;
      return p_param_1.execute(p_automate) % l_b ;
      }




/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v2c && ((p_v2 == 0) || (p_v2 == 1) || (p_v2 == -1)))
        {
        return Constant.create_constant(0);
        }
        
      if(p_v1c && (p_v1 == 0)) return p_sub1;
      
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 % p_v2);
            
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CZERO;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The lt-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Lt extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the lt operator.
 */

    private static final char[] NAME = new char[] {'<'};
/**
 * Create a new operation.
 */

    Lt()
      {
      super(NAME, false);
      }

/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) <
              p_param_2.execute(p_automate)) ? TRUE : FALSE;
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c)
            return Constant.create_constant((p_v1 < p_v2) ? TRUE : FALSE);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CFALSE;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The ltw-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Lte extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the lte operator.
 */

    private static final char[] NAME = new char[] {'<''='};
/**
 * Create a new operation.
 */

    Lte()
      {
      super(NAME, false);
      }

/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) <=
              p_param_2.execute(p_automate)) ? TRUE : FALSE;
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(
                                      (p_v1 <= p_v2) ? TRUE : FALSE);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CTRUE;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The gt-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Gt extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the gt operator.
 */

    private static final char[] NAME = new char[] {'>'};
/**
 * Create a new operation.
 */

    Gt()
      {
      super(NAME, false);
      }

/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) >
              p_param_2.execute(p_automate)) ? TRUE : FALSE;
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(
                                      (p_v1 > p_v2) ? TRUE : FALSE);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CFALSE;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The gte-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Gte extends BinaryOperation
    {
 /**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the gte operator.
 */

    private static final char[] NAME = new char[] {'>''='};

/**
 * Create a new operation.
 */

    Gte()
      {
      super(NAME, false);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) >=
              p_param_2.execute(p_automate)) ? TRUE : FALSE;
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(
                                  (p_v1 >= p_v2) ? TRUE : FALSE);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CTRUE;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }

/**
 * The eq-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Eq extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the equal operator.
 */

    private static final char[] NAME = new char[] {'=''='};
/**
 * Create a new operation.
 */

    Eq()
      {
      super(NAME, true);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) ==
              p_param_2.execute(p_automate)) ? TRUE : FALSE;
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(
                                      (p_v1 == p_v2) ? TRUE : FALSE);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CTRUE;
      
      if(p_v1c && (p_v1 == 0))
        {
        return new UnaryExpression(UnaryExpression.LNOT, p_sub2);
        }
      
      if(p_v2c && (p_v2 == 0))
        {
        return new UnaryExpression(UnaryExpression.LNOT, p_sub1);
        }
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }


/**
 * The neq-operation.
 *
 * @author Thomas Weise
 */

  private static  final class Neq extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the neq operator.
 */

    private static final char[] NAME = new char[] {'!''='};
/**
 * Create a new operation.
 */

    Neq()
      {
      super(NAME, true);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) !=
              p_param_2.execute(p_automate)) ? TRUE : FALSE;
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && p_v2c) return Constant.create_constant(
                                  (p_v1 != p_v2) ? TRUE : FALSE);
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CFALSE;
      
      if(p_v1c && (p_v1 == 0)) return p_sub2;
      if(p_v2c && (p_v2 == 0)) return p_sub1;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }



/**
 * The BAnd-operation.
 *
 * @author Thomas Weise
 */

  private static  final class BAnd extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the binary and operator.
 */

    private static final char[] NAME = new char[] {'&'};
/**
 * Create a new operation.
 */

    BAnd()
      {
      super(NAME, true);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) &
              p_param_2.execute(p_automate));
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return p_sub1;
      
//      if(p_v1c && (p_v1 == 0)) return p_sub1;
//      if(p_v2c && (p_v2 == 0)) return p_sub2;
      if(p_v1c && (p_v1 == -1)) return p_sub1;
      if(p_v2c && (p_v2 == -1)) return p_sub2;
      
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 & p_v2);
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }
/**
 * The BOr-operation.
 *
 * @author Thomas Weise
 */

  private static  final class BOr extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the binary or operator.
 */

    private static final char[] NAME = new char[] {'|'};
/**
 * Create a new operation.
 */

    BOr()
      {
      super(NAME, true);
      }


/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) |
              p_param_2.execute(p_automate));
      }


    
/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return p_sub1;
      
      if(p_v1c && (p_v1 == 0)) return p_sub1;
      if(p_v2c && (p_v2 == 0)) return p_sub2;
//      if(p_v1c && (p_v1 == -1)) return p_sub1;
//      if(p_v2c && (p_v2 == -1)) return p_sub2;
      
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 | p_v2);
            
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }
/**
 * The BXor-operation.
 *
 * @author Thomas Weise
 */

  private static  final class BXor extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the binary xor operator.
 */

    private static final char[] NAME = new char[] {'^'};
/**
 * Create a new operation.
 */

    BXor()
      {
      super(NAME, true);
      }

/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      return (p_param_1.execute(p_automate) ^
              p_param_2.execute(p_automate));
      }


/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {      
      if(p_v1c && p_v2c) return Constant.create_constant(p_v1 ^ p_v2);
      
      if(p_v1c && (p_v1 == 0)) return p_sub2;
      if(p_v2c && (p_v2 == 0)) return p_sub1;
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return Constant.CZERO;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }
/**
 * The LAnd-operation.
 *
 * @author Thomas Weise
 */

  private static  final class LAnd extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the logic and operator.
 */

    private static final char[] NAME = new char[] {'&''&'};
/**
 * Create a new operation.
 */

    LAnd()
      {
      super(NAME, true);
      }

/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      int l_b;

      l_b = p_param_1.execute(p_automate);
      if(l_b == 0) return 0;
      return (p_param_2.execute(p_automate) != 0) ? TRUE : FALSE;
      }


/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && is_false(p_v1)) return Constant.CFALSE;      
      if(p_v2c && is_false(p_v2)) return Constant.CFALSE;
      
      if(p_v1c && p_v2c)
        {
        return ((is_true(p_v1) && is_true(p_v2)) ? Constant.CTRUE
                                                 : Constant.CFALSE);
        }
      
      if(p_v1c && is_true(p_v1))  return p_sub2;
      if(p_v2c && is_true(p_v2))  return p_sub1;
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return p_sub1;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }     
      
      return p_source;
      }
    }
/**
 * The LOr-operation.
 *
 * @author Thomas Weise
 */

  private static  final class LOr extends BinaryOperation
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * The name of the logical or operator.
 */

    private static final char[] NAME = new char[] {'|''|'};
/**
 * Create a new operation.
 */

    LOr()
      {
      super(NAME, true);
      }

/**
 * Calculate the expression's value for the specified automate.
 * @param p_param_1     The first parameter.
 * @param p_param_2     The second parameter.
 * @param p_automate    The automate instance to execute the expression
 *                      for.
 * @return  The value of the expression.
 */

    @Override
    final int   execute (final Expression p_param_1,
                         final Expression p_param_2,
                         final Automaton  p_automate)
      {
      int l_b;

      l_b = p_param_1.execute(p_automate);
      if(l_b != 0) return TRUE;
      return (p_param_2.execute(p_automate) != 0)
                    ? TRUE : FALSE;
      }


/**
 * Optimize the binary expression p_source.
 * @param p_source  The expression to be optimized. This expression uses
 *                  this operator.
 * @param p_v1c     <code>true</code> if the value of the first sub
 *                  expression is constant.
 * @param p_v1      The value of the first sub expression, if constant.
 * @param p_v2c     <code>true</code> if the value of the second sub
 *                  expression is constant.
 * @param p_v2      The value of the second sub expression, if constant.
 * @param p_sub1    The first optimized subexpression.
 * @param p_sub2    The second optimized subexpression.
 * @return  The optimized expression, or <code>p_source</code> if no
 *          optimization could be found.
 */

    @Override
    final  Expression     do_optimize (final BinaryExpression p_source,
                                       final boolean          p_v1c,
                                       final int              p_v1,
                                       final boolean          p_v2c,
                                       final int              p_v2,                                       
                                       final Expression       p_sub1,
                                       final Expression       p_sub2)
      {
      if(p_v1c && is_true(p_v1)) return Constant.CTRUE;
      if(p_v2c && is_true(p_v2)) return Constant.CTRUE;
      
      if(p_v1c && p_v2c)
        {
        return ((is_false(p_v1) && is_false(p_v2)) ? Constant.CFALSE
                                                   : Constant.CTRUE);
        }
      
      if(p_v1c && is_false(p_v1))  return p_sub2;
      if(p_v2c && is_false(p_v2))  return p_sub1;
      
      if(p_sub1.equals(p_sub2) && eq(p_sub1)) return p_sub1;
      
      if( (p_sub1 != p_source.get_sub_1()) ||
          (p_sub2 != p_source.get_sub_2()) )
        {
        p_source.init(p_sub1, p_sub2); 
        }
      
      return p_source;
      }
    }
  }

File Information:

file name:BinaryExpression.java
package:org.dgpf.gp.automaton.expressions
qualified name:org.dgpf.gp.automaton.expressions.BinaryExpression.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/automaton/expressions/BinaryExpression.java
size:60.076 KB (61518 B)
uploaded: 2015-07-22 04:10:55 GMT+0000
last update: 2006-05-08 13:38:45 GMT+0000
last access: 2017-11-19 02:50:56 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 02:50:56 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo