valuefunction.java

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

/*
* The contents of this file are subject to the BT "ZEUS" Open Source 
* Licence (L77741), Version 1.0 (the "Licence"); you may not use this file 
* except in compliance with the Licence. You may obtain a copy of the Licence
* from $ZEUS_INSTALL/licence.html or alternatively from
* http://www.labs.bt.com/projects/agents/zeus/licence.htm
* 
* Except as stated in Clause 7 of the Licence, software distributed under the
* Licence is distributed WITHOUT WARRANTY OF ANY KIND, either express or 
* implied. See the Licence for the specific language governing rights and 
* limitations under the Licence.
* 
* The Original Code is within the package zeus.*.
* The Initial Developer of the Original Code is British Telecommunications
* public limited company, whose registered office is at 81 Newgate Street, 
* London, EC1A 7AJ, England. Portions created by British Telecommunications 
* public limited company are Copyright 1996-9. All Rights Reserved.
* 
* THIS NOTICE MUST BE INCLUDED ON ANY COPY OF THIS FILE
*/



package zeus.concepts.fn;

import java.util.*;
import zeus.util.*;
import zeus.concepts.*;

public abstract class ValueFunction {
/*
	Precedence values

	0	CONSB
	1	LVAR
	2	ELSE, IMPLY
	3	ARITH, FUNC, METH
        4       COMP, LAND, LNOT, LOR
	5	AND
	6	OR
	7	CONS, FACT?
	8	FIELD
        9
	10	VECT, BOOL, DATE, ID, INT, REAL, TYPE, TIME
*/

   static final int ID_MIN = 0;
   static final int ID_MAX = 23;


   public static final int CONSB = 0;
   public static final int LVAR  = 1;
   public static final int ID    = 2;
   public static final int TYPE  = 3;
   public static final int FIELD = 4;
   public static final int AND   = 5;
   public static final int OR    = 6;
   public static final int CONS  = 7;
   public static final int IMPLY = 8;
   public static final int ELSE  = 9;
   public static final int LOR   = 10;
   public static final int LAND  = 11;
   public static final int LNOT  = 12;
   public static final int COMP  = 13;
   public static final int INT   = 14;
   public static final int REAL  = 15;
   public static final int DATE  = 16;
   public static final int TIME  = 17;
   public static final int BOOL  = 18;
   public static final int ARITH = 19;
   public static final int FACT  = 20;
   public static final int FUNC  = 21;
   public static final int METH  = 22;
   public static final int VECT  = 23;

   static final int PD_MIN = 0;
   static final int PD_MAX = 10;

   protected int type = -1;
   protected int precedence = -1;

   public ValueFunction(int type, int precedence) {
      Assert.notFalse(type >= ID_MIN && type <= ID_MAX);
      Assert.notFalse(precedence >= PD_MIN && precedence <= PD_MAX);
      this.type = type;
      this.precedence = precedence;
   }

   public final int getID() { return type; }
   public final int getPD() { return precedence; }

   public abstract boolean isDeterminate();
   public abstract boolean references(ValueFunction var);

   public final ValueFunction unifiesWith(ValueFunction fn, Bindings b) {
      ValueFunction x, y, z;
      
      x = this.resolve(b);
      y = fn.resolve(b);

      if ( x == null || y == null ) return null;

      x = x.normalize();
      y = y.normalize();

      if ( x.equals(y) ) return y;

      z = (y.getPD() < x.getPD() ?  y.unify(x,b) : x.unify(y,b));

      if ( z == null )
         return null;

      z = z.simplify();
      b.set(x,z);
      b.set(y,z);
      return z;
   }

   public ValueFunction resolve(Bindings b) {
      return resolve(new ResolutionContext(), b);
   }
   public ValueFunction resolve(ResolutionContext c, Bindings b) {
      return b.lookUp(this);
   }
   public Vector variables() {
      return new Vector();
   }
   public ValueFunction duplicate(String name, GenSym genSym) {
      DuplicationTable table = new DuplicationTable(name,genSym);
      return duplicate(table);
   }
   public ValueFunction duplicate(DuplicationTable table) {
      return this;
   }
   public ValueFunction evaluationFn() {
      return this;
   }
   public int baseID() {
      return type;
   }

   abstract Object        getArg(int position);
   abstract ValueFunction unify(ValueFunction fn, Bindings b);

   public abstract ValueFunction mirror();

   ValueFunction normalize()    { return this; }
   ValueFunction simplify()     { return this; }

   final Object getArg()        { return getArg(0); }

   /*
      List of methods associated with this ValueFunction type
   */

   static final String[] METHOD_LIST = {
      "isDeterminate", "0",
      "toString", "0"
   };

   static final int IS_DETERMINATE = 0;
   static final int TO_STRING      = 2;

   ValueFunction invokeMethod(String method, Vector args) {
      int arity;
      int position = Misc.whichPosition(method,METHOD_LIST);

      if ( position != -1 ) {
         arity = Integer.parseInt(METHOD_LIST[position+1]);
         if ( args.size() != arity )
            throw new IllegalArgumentException(
               "Wrong number of arguments in method \'" + method + "/" +
                arity + "\'.");
      }
      else {
         throw new IllegalArgumentException(
            "Unknown method \'" + method + "\' invoked on \'" + this +"\'");
      }

      switch( position ) {
         case IS_DETERMINATE:
              return isDeterminate() ? BoolFn.trueFn : BoolFn.falseFn;

         case TO_STRING:
              return new IdFn(toString());

         default:
              throw new IllegalArgumentException(
                 "Unknown method \'" + method + "\' invoked on \'" + this +"\'");
      }
   }
}