Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package jason.asSyntax;
  
  
  import java.util.Iterator;
 
Represents an arithmetic function, like math.max(arg1,arg2) -- a functor (math.max) and two arguments. A Structure is thus used to store the data.

Author(s):
Jomi
Composed:
- "arguments (from Structure.terms)" 0..* Term
 
 public class ArithFunctionTerm extends Structure implements NumberTerm {
 
     private static final long serialVersionUID = 1L;
 
     private static Logger logger = Logger.getLogger(ArithFunctionTerm.class.getName());
     
     protected NumberTerm value = null// value, when evaluated
 
     private ArithFunction function = null;
     
     private Agent agent = null// the agent where this function was used
 
     public ArithFunctionTerm(ArithFunction function) {
         super(function.getName(), 2);
         this. = function;   
     }
 
     public ArithFunctionTerm(ArithFunctionTerm af) {
         super(af); // clone args from af
          = af.function;
             = af.agent;
     }
     
     public ArithFunctionTerm(String functorint arity) {
         super(functor,arity);
     }
         
     @Override
     public boolean isNumeric() {
         return true;
     }
     
     @Override
     public boolean isAtom() {
         return false;
     }
     
     @Override
     public boolean isStructure() {
         return false;
     }
     
     @Override
     public boolean isLiteral() {
         return false;
     }
 
     @Override
     public boolean isArithExpr() {
         return true;
     }
     
     public void setAgent(Agent ag) {
          = ag;
     }
     public Agent getAgent() {
         return ;
     }
    
    
computes the value for this arithmetic function (as defined in the NumberTerm interface)
 
     @Override
     public Term capply(Unifier u) {
         if ( == null) {
             .log(.getErrorMsg()+ " -- the function can not be evalutated, it has no function assigned to it!"new Exception());
         } else {
             Term v = super.capply(u);
             if (.allowUngroundTerms() || v.isGround()) {
                 try {         
                      = new NumberTermImpl(.evaluate(( == null ? null : .getTS()), ((Literal)v).getTermsArray()));
                     return ;
                 } catch (NoValueException e) {
                     // ignore and return this;
                 } catch (Exception e) {
                     .log(.getErrorMsg()+ " -- error in evaluate!"e);
                 }
             //} else {
            //    logger.warning(getErrorMsg()+ " -- this function has unground arguments and can not be evaluated! Unifier is "+u);  
            }
        }
        return clone();
    }
    public double solve() throws NoValueException {
        if ( == null// try to solve without unifier
            capply(null);
        if ( == null)
            throw new NoValueException();
        else
            return .solve();
    }
    
    public boolean checkArity(int a) {
        return  != null && .checkArity(a);
    }
    
    @Override
    public Iterator<UnifierlogicalConsequence(Agent agUnifier un)  {
        .log(."Arithmetic term cannot be used for logical consequence!"new Exception());
        return ..iterator();
    }
    
    @Override
    public boolean equals(Object t) {
        if (t == nullreturn false;
        return super.equals(t);
    }
    @Override
    public int compareTo(Term o) {
        if (o instanceof VarTerm) {
            return o.compareTo(this) * -1;
        }
        return super.compareTo(o);
        /*if (o instanceof NumberTerm) {
            NumberTerm st = (NumberTerm)o;
            if (solve() > st.solve()) return 1;
            if (solve() < st.solve()) return -1;
            return 0;
        }
        return -1;*/
    }
    @Override    
    public String getErrorMsg() {
        return "Error in '"+this+"' ("super.getErrorMsg() + ")";       
    }
    @Override
    public NumberTerm clone() {
        return new ArithFunctionTerm(this);
    } 
    
    public Element getAsDOM(Document document) {
        Element u = (Elementdocument.createElement("expression");
        u.setAttribute("type""arithmetic");
        Element r = (Elementdocument.createElement("right");
        r.appendChild(super.getAsDOM(document)); // put the left argument indeed!
        u.appendChild(r);
        return u;
    }
New to GrepCode? Check out our FAQ X