Java Unifier类代码示例

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void testLogCons2() {
    Agent ag = new Agent();
    ag.initAg();
    
    Rule r = new Rule(Literal.parseLiteral("r([],a(X),b(X,4))"), Literal.parseLiteral("true"));
    ag.getBB().add(r);

    Iterator<Unifier> iun = Literal.parseLiteral("r([],a(20),X)").logicalConsequence(ag, new Unifier());
    //assertEquals(iun.next().get("X").toString(),"b(20,4)");
    assertTrue(iun.hasNext());
    Literal result = Literal.parseLiteral("r([],a(20),X)");
    Unifier u = iun.next();
    assertTrue(u.get("X").isStructure());
    assertEquals( ((Structure)u.get("X")).getArity(), 2);
    assertEquals( ((Structure)u.get("X")).getFunctor(), "b");
    assertEquals(result.capply(u), Literal.parseLiteral("r([],a(20),b(20,4))"));
    
    iun = Literal.parseLiteral("r([],a(20),b(X,Y))").logicalConsequence(ag, new Unifier());
    u = iun.next();
    assertEquals(u.get("X"), ASSyntax.createNumber(20));
    assertEquals(u.get("Y"), ASSyntax.createNumber(4));

}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void testMakeVarAnnon1() {
    Literal l1 = Literal.parseLiteral("likes(jane,X,peter)");
    Literal l2 = Literal.parseLiteral("likes(X,Y,Y)");
    Literal l3 = Literal.parseLiteral("likes(X,Y,X)");
    Literal l4 = Literal.parseLiteral("likes(Z,Y,Y)");
    Unifier u = new Unifier();                
    assertFalse(u.unifies(l1, l2));
    u.clear();      
    assertFalse(u.unifies(l1, l3));
    u.clear();      
    assertTrue(u.unifies(l1, l4));
    
    l2.makeVarsAnnon();
    u.clear();      
    assertTrue(u.unifies(l1, l2));      

    l3.makeVarsAnnon();
    u.clear();
    assertFalse(u.unifies(l1, l3));     

    l4.makeVarsAnnon();
    u.clear();      
    assertTrue(u.unifies(l1, l4));      
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override
public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
    checkArguments(args);

    if (args[0].isNumeric() && args[1].isString()) {
        return un.unifies(args[2], deleteFromString((int)((NumberTerm)args[0]).solve(),(StringTerm)args[1]));
    } 
    if (args[0].isNumeric() && args[1].isList()) {
        return un.unifies(args[2], deleteFromList((int)((NumberTerm)args[0]).solve(),(ListTerm)args[1]));
    }
    if (args[0].isString() && args[1].isString()) {
        return un.unifies(args[2], deleteFromString((StringTerm)args[0],(StringTerm)args[1]));
    }
    if (args[0].isString()) { // consider arg[1] as string
        return un.unifies(args[2], deleteFromString((StringTerm)args[0], new StringTermImpl(args[1].toString())));
    }
    
    
    // first element as term
    if (args[1].isList()) {
        return un.unifies(args[2], deleteFromList(args[0],(ListTerm)args[1], un.clone()));
    }
    throw new JasonException("Incorrect use of the internal action '.delete' (see documentation).");
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void testVarTermAsNumber() throws Exception {
    Term k = new VarTerm("K");
    Unifier u = new Unifier();
    NumberTermImpl n = new NumberTermImpl(10);
    assertTrue(n.isNumeric());
    assertFalse(n.isVar());
    assertTrue(u.unifies(k, n));
    k = k.capply(u);
    // System.out.println(k+" u="+u);
    assertTrue(k.isNumeric());
    assertFalse(k.isLiteral());

    ArithExpr exp = new ArithExpr((NumberTerm)k, ArithmeticOp.plus, new NumberTermImpl(20));
    assertTrue(exp.solve() == 30d);
    NumberTerm nt = ArithExpr.parseExpr("5 div 2");
    assertTrue(nt.solve() == 2d);
    nt = ArithExpr.parseExpr("5 mod 2");
    assertTrue(nt.solve() == 1d);
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void testUnify2() throws ParseException {
    Unifier u = new Unifier();
    u.unifies(new VarTerm("X"), new NumberTermImpl(3));
    Term e1 = ASSyntax.parseTerm("X-1");
    e1 = e1.capply(u);
    assertTrue(u.unifies(new NumberTermImpl(2), e1));
    assertTrue(u.unifies(e1, new NumberTermImpl(2)));
    assertTrue(u.unifies(new NumberTermImpl(2), e1.clone()));

    u.unifies(new VarTerm("Y"), new NumberTermImpl(1));
    Term e2 = ASSyntax.parseTerm("Y+1");
    e2 = e2.capply(u);
    assertFalse(e1.isLiteral());
    assertFalse(e2.isLiteral());
    assertTrue(u.unifies(e2, e1));
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override
public Literal makeVarsAnnon(Unifier un) {
    if (annots != null) {
        ListTerm lt = annots;
        while (!lt.isEmpty()) {
            Term ta = lt.getTerm();
            if (ta.isVar())
                lt.setTerm(varToReplace(ta, un));
            else if (ta instanceof Structure)
                ((Structure)ta).makeVarsAnnon(un);
            if (lt.isTail() && lt.getNext().isVar()) {
                lt.setNext(varToReplace(lt.getNext(), un));
                break;
            }
            lt = lt.getNext();
        }
    }
    return super.makeVarsAnnon(un);
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
    checkArguments(args);
    
    Agent ag = ts.getAg();
    Pred inc = new Pred(ns, "include");
    inc.addTerms(args);
    
    Agent result = ((Include)DirectiveProcessor.getDirective("include")).process(
            inc, 
            ag, 
            null);
    
    ag.importComponents(result);
    ag.addInitialBelsInBB();
    ag.addInitialGoalsInTS();
    return true;
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void testLogConsWithAnnotsBacktracking() {
    Agent ag = new Agent();
    ag.initAg();

    ag.getBB().add(Literal.parseLiteral("p(10)[source(ag1),source(ag2),b,40,2]"));
    ag.getBB().add(Literal.parseLiteral("p(10)[source(ag3),source(ag2),b,40,2]"));
    ag.getBB().add(Literal.parseLiteral("p(20)[source(ag4),source(ag2),b,u,k]"));
    ag.getBB().add(Literal.parseLiteral("p(30)[source(ag5),source(ag2),40,u,k]"));

    Iterator<Unifier> iun = Literal.parseLiteral("p(Y)[source(X),b]").logicalConsequence(ag, new Unifier());
    int c = 0;
    while (iun.hasNext()) {
        iun.next();
        c++;
    }
    assertEquals(5, c);
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override
public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
    checkArguments(args);

    ListTerm list = (ListTerm)args[0];
    if (list.isEmpty()) {
        return false;               
    }

    Iterator<Term> i = list.iterator();
    Term min = i.next();
    while (i.hasNext()) {
        Term t = i.next();
        if (compare(min,t)) {
            min = t;
        }
    }
    return un.unifies(args[1], min.clone());
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
/** Removes all percepts from the common perception list that unifies with <i>per</i>.
 *  
 *  Example: removePerceptsByUnif(Literal.parseLiteral("position(_)")) will remove 
 *  all percepts that unifies "position(_)".
 *  
 *  @return the number of removed percepts.
 */
public int removePerceptsByUnif(Literal per) {
    int c = 0;
    if (! percepts.isEmpty()) { // has global perception?
        synchronized (percepts) {
            Iterator<Literal> i = percepts.iterator();
            while (i.hasNext()) {
                Literal l = i.next();
                if (new Unifier().unifies(l,per)) {
                    i.remove();
                    c++;
                }
            }
        }
        if (c>0) uptodateAgs.clear();
    }
    return c;
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override
public Object execute(TransitionSystem ts, Unifier un, Term[] terms) throws Exception{
	try {
		boolean result = false;
		int iagx = (int)((NumberTerm)terms[0]).solve();//Atual
        int iagy = (int)((NumberTerm)terms[1]).solve();//Atual
        String dir = terms[2].toString();
        if(dir.equals("up")) {
        	result = (un.unifies(terms[3], new Atom(String.valueOf(iagx))) && un.unifies(terms[4], new Atom(String.valueOf(1))));  	
        }else if(dir.equals("down")) {
        	result = (un.unifies(terms[3], new Atom(String.valueOf(iagx))) && un.unifies(terms[4], new Atom(String.valueOf(48))));
        }else if(dir.equals("left")) {
        	result = (un.unifies(terms[3], new Atom(String.valueOf(1))) && un.unifies(terms[4], new Atom(String.valueOf(iagy))));
        }else if(dir.equals("right")) {
        	result = (un.unifies(terms[3], new Atom(String.valueOf(48))) && un.unifies(terms[4], new Atom(String.valueOf(iagy))));
        }
        return result;
        
	}catch(Throwable e) {
		e.printStackTrace();
		return false;
	}
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void testObTerm() {
    ObjectTerm term = new ObjectTermImpl("test");
    assertTrue(term.equals(term));

    assertTrue(new Unifier().unifies(new ObjectTermImpl("test"), new ObjectTermImpl("test")));
    String string = "test";
    assertTrue(new Unifier().unifies(new ObjectTermImpl(string), new ObjectTermImpl(string)));

    BeliefBase base = new DefaultBeliefBase();
    base.add(ASSyntax.createLiteral("test", new ObjectTermImpl("test")));
    Iterator<Literal> iterator = base.getCandidateBeliefs(ASSyntax.createLiteral("test", new ObjectTermImpl("test")), new Unifier());
    assertTrue(iterator != null && iterator.hasNext());

    Literal result = iterator.next();
    assertTrue(result.getFunctor().equals("test"));
    assertTrue(result.getTerm(0).getClass().equals(ObjectTermImpl.class));
    assertTrue(result.getTerm(0).equals(new ObjectTermImpl("test")));

    assertFalse(iterator.hasNext());

}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
public void makeVarsAnnon(Literal l, Unifier un) {
    try {
        for (int i=0; i<l.getArity(); i++) {
            Term t = l.getTerm(i);
            if (t.isString()) {
                StringTerm st = (StringTerm)t;
                Matcher matcher = regex.matcher(st.getString());
                StringBuffer sb = new StringBuffer();

                while (matcher.find()) {
                    String sVar = matcher.group();
                    sVar = sVar.substring(2, sVar.length() - 1);
                    Term v = ASSyntax.parseTerm(sVar);
                    if (v.isVar()) {
                        VarTerm to = ((Structure)l).varToReplace(v, un);
                        matcher.appendReplacement(sb, "#{"+to.toString()+"}");
                    }
                }
                matcher.appendTail(sb);
                l.setTerm(i, new StringTermImpl(sb.toString()));
            }
        }
    } catch (ParseException pe) {
        pe.printStackTrace();
    }
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override
public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
    checkArguments(args);
    
    // try to get the intention from the "body"
    Intention i = ts.getC().getSelectedIntention();

    if (i == null) {
        // try to get the intention from the event
        Event evt = ts.getC().getSelectedEvent();
        if (evt != null)
            i = evt.getIntention();
    }
    if (i != null)
        return un.unifies(i.getAsTerm(), args[0]);
    else
        return false;            
}
 

import jason.asSemantics.Unifier; //导入依赖的package包/类
@Override
public boolean dropGoal(Trigger te, Unifier un) {
    boolean r = super.dropGoal(te, un);
    if (r && size() < forkPoint) {
        //System.out.println("drop "+te+" i.size = "+size()+" fork point "+forkPoint+" to f "+fd+"\n"+this);
        if (fd.toFinish > 0) { // the first intentions of the fork being dropped, keep it and ignore the rest
            fd.toFinish = 0;
            //System.out.println("put it back");
            return true;
        } else {
            clearIM();
            //System.out.println("ignore intention");
            return false;
        }
    } 
    return r;
}