constraintfn.java

人工智能中Agent开发包。多 Agent 系统是处理自治 Agent 之间知识层的协作问题

            this + "\'");
      }

      switch(op) {
         case LE:
         case GE:
         case LT:
         case GT:
              switch(v.getID()) {
                 case ID:
                 case DATE:
                 case TIME:
                 case INT:
                 case REAL:
                      return compare((ConstraintFn)u,(PrimitiveFn)v);

                 case CONS:
                      return checkRange((ConstraintFn)u,(ConstraintFn)v);

                 default:
                    throw new IllegalArgumentException("Illegal operand in \'" +
                       this + "\'");
              }

         case UN:
         case NE:
              switch(v.getID()) {
                 // The commented types should all resolve to primitives
                 // case LVAR:
                 // case FIELD:
                 // case ARITH:
                 // case IMPLY:
                 // case ELSE:
                 // case LOR:
                 // case LAND:
                 // case LNOT:
                 // case COMP:
                 // case FUNC:
                 // case METH:
                 // case CONSB:

                 case ID:
                 case TYPE:
                 case AND:
                 case OR:
                 case DATE:
                 case TIME:
                 case BOOL:
                 case INT:
                 case REAL:
                 case VECT:
                      if (((ValueFunction)u.getArg()).unifiesWith(v,b) == null)
                         return v;
                      else
                         return null;

                 case CONS:
                    switch(((ConstraintFn)v).getOperator()) {
                       case UN:
                       case NE:
                            if ( u.equals(v) )
                               return u;
                            else
                               return new AndFn(u,v);

                       default:
                          return checkRange((ConstraintFn)u,(ConstraintFn)v);
                    }
              }
              break;

         default:
              throw new IllegalArgumentException("Illegal operand in \'" +
                 this + "\'");
      }
      return null;
   }
   
   
   public int baseID() {
      // must be called when Fn is known to be determinate
      return arg.baseID();
   }



   static ValueFunction compare(ConstraintFn a, PrimitiveFn b) {
      PrimitiveFn x = (PrimitiveFn)a.getArg();
      switch(a.getOperator()) {
         case LE:
// System.err.println("Compare LE " + a + " and " + b);
              if ( b.less(x) || b.equals(x) )
                 return (ValueFunction)b;
              else
                 return null;

         case GE:
// System.err.println("Compare GE " + a + " and " + b);
              if ( x.less(b) || x.equals(b) )
                 return (ValueFunction)b;
              else
                 return null;

         case LT:
// System.err.println("Compare LT " + a + " and " + b);
              if ( b.less(x) )
                 return (ValueFunction)b;
              else
                 return null;
         case GT:
// System.err.println("Compare GT " + a + " and " + b);
              if ( x.less(b) )
                 return (ValueFunction)b;
              else
                 return null;
         default:
// System.err.println("Compare DEFAULT " + a + " and " + b);
              Assert.notNull(null);
              return null;
      }
   }


   static ValueFunction checkRange(ConstraintFn a, ConstraintFn b) {
// System.err.println("CheckRange " + a + " and " + b);
      if ( a.getOperator() > b.getOperator() )
         return checkRange(b,a);

      PrimitiveFn x = (PrimitiveFn) a.getArg();
      PrimitiveFn y = (PrimitiveFn) b.getArg();

      switch( a.getOperator() ) {
         case LE:
// System.err.println("CheckRange LE " + a + " and " + b);
              switch( b.getOperator() ) {
                 case LE:
                      return ( x.less(y) ? a : b );

                 case LT:
                      if ( x.equals(y) )
                         return null;
                      else if ( x.less(y) )
                         return a;
                      else
                         return b;

                 case GE:
                      if ( x.equals(y) )
                         return (ValueFunction)x;
                      else if ( y.less(x) )
                         return new AndFn(a,b);
                      else
                         return null;

                 case GT:
                      if ( y.less(x) )
                         return new AndFn(a,b);
                      else
                         return null;

                 case UN:
                 case NE:
                      if ( x.equals(y) )
                         return new ConstraintFn(operators[LT],(ValueFunction)x);
                      else if ( x.less(y) )
                         return a;
                      else
                         return new AndFn(a,b);
              }
              break;

         case LT:
// System.err.println("CheckRange LT " + a + " and " + b);
              switch( b.getOperator() ) {
                 // case LE: already done
                 case LT:
                      return ( x.less(y) ? a : b );

                 case GE:
                 case GT:
                      if ( y.less(x) )
                         return new AndFn(a,b);
                      else
                         return null;

                 case UN:
                 case NE:
                      if ( y.less(x) )
                         return new AndFn(a,b);
                      else
                         return a;
              }
              break;

         case GE:
// System.err.println("CheckRange GE " + a + " and " + b);
              switch( b.getOperator() ) {
                 // case LE: already done
                 // case LT: already done
                 case GE:
                      return (x.less(y) ? (ValueFunction)y : (ValueFunction)x);

                 case GT:
                      if ( x.equals(y) )
                         return null;
                      else if ( x.less(y) )
                         return b;
                      else
                         return a;

                 case UN:
                 case NE:
                      if ( x.equals(y) )
                         return new ConstraintFn(operators[GT],(ValueFunction)x);
                      else if ( x.less(y) )
                         return new AndFn(a,b);
                      else
                         return a;
              }
              break;

         case GT:
// System.err.println("CheckRange GT " + a + " and " + b);
              switch( b.getOperator() ) {
                 // case LE:
                 // case LT:
                 // case GE:
                 case GT:
                      return ( x.less(y) ? b : a );

                 case UN:
                 case NE:
                      if ( x.less(y) )
                         return new AndFn(a,b);
                      else
                         return a;
              }
              break;

         case UN:
         case NE:
// System.err.println("CheckRange NE " + a + " and " + b);
              switch( b.getOperator() ) {
                 // case LE:
                 // case LT:
                 // case GE:
                 // case GT:
                 case UN:
                 case NE:
                      return ( x.equals(y) ? (ValueFunction)a
                                           : (ValueFunction)(new AndFn(a,b)) );
              }
              break;
      }
      Assert.notNull(null); // should never get here
      return null;
   }

}