prolog.java

人工智能代码JAVA程序,包括神经网络,遗传算法

        } else todo.push(new rack(q,r));
    }

    void query(term q) {
        time=System.currentTimeMillis();
        todo=new Stack();
        done=new Stack();
        subst=new Stack();
        todo.push(new rack(ASK,null));
        uservars=new Vector();
        term.vars(q,uservars);
        stacktodo(q,null);
        run(5000); // max iters
        //mythread=new Thread(this);
        //mythread.start();
    }

    static int FALSE=0,TRUE=1,ERROR=-1;
    int solve(rack r) {
        /*return one of FALSE=0,TRUE=1,ERROR=-1*/
        if(r.solveoption==r.NOTAGAIN)
            return FALSE;
        term rpred=term.skipeq(r.pred);
        if(rpred.type!=term.FUNCTOR)
            return ERROR;
        String fname=rpred.name;

        int bi=getbinum(rpred);
        if(bi!=-1) {
            char c;
            term t,l;

            switch(bi){
            case 1:return TRUE;
            case 2:return FALSE;
            case 3:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            case 4:
                r.solveoption=r.NOTAGAIN;
                rack todo1;
                rack realparent=r.parent;
                while(realparent!=null&&
                      (realparent.pred.name==prologop.AND||
                       realparent.pred.name==prologop.OR))
                    {realparent=realparent.parent;}
                int todop=todo.size()-1;
                while(todop>=0) {
                    todo1=(rack)todo.elementAt(todop);
                    if(todo1.parent!=null&&
                       (todo1.parent.pred.name==prologop.AND||
                        todo1.parent.pred.name==prologop.OR) )
                        {
                            todo1.parent=realparent;
                            todop--;
                        }
                    else break;
                }
                r.parent=realparent;

                while(!done.empty()) {
                    if(done.peek()!=r.parent)
                        done.pop();
                    else
                        break;
                }
                if(r.parent!=null)
                    r.parent.solveoption=r.NOTAGAIN;
                return TRUE;
            case 5:
                r.solveoption=r.NOTAGAIN;
                if(term.match(rpred.arg[0],rpred.arg[1],subst))
                    return TRUE;
                else
                    return FALSE;
            case 6:
                r.solveoption=r.NOTAGAIN;
                int n=term.numbervalue(rpred.arg[1]);
                if(n==term.NaN)
                    return ERROR;
                if(term.match(rpred.arg[0],new term(n),subst))
                    return TRUE;
                else
                    return FALSE;
            case 7:
            case 8:
            case 9:
            case 10:
            case 11:
            case 12:
                r.solveoption=r.NOTAGAIN;
                int n1=term.numbervalue(rpred.arg[0]);
                int n2=term.numbervalue(rpred.arg[1]);
                if(n1==term.NaN||n2==term.NaN) {
                    System.out.println("No number");
                    return ERROR;
                }
                if((bi==8&&n1<n2)||
                   (bi==9&&n1>n2)||
                   (bi==10&&n1<=n2)||
                   (bi==11&&n1>=n2)||
                   (bi==7&&n1==n2)||
                   (bi==12&&n1!=n2))
                    return TRUE;
                else
                    return FALSE;
            case 15:
                r.solveoption=r.NOTAGAIN;
                do{
                    c=inp.get0();
                }while(c<=32);
                if(term.match(rpred.arg[0],new term((int)c),subst))
                    return TRUE;
                else
                    return FALSE;
            case 16:
                r.solveoption=r.NOTAGAIN;
                c=inp.get0();
                if(term.match(rpred.arg[0],new term((int)c),subst))
                    return TRUE;
                else
                    return FALSE;
            case 17:
                r.solveoption=r.NOTAGAIN;
                inp=null;
                return TRUE;
            case 19:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            case 20:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            case 21:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type==term.NUMBER&&t.arity>=0&&t.arity<256)
                    {
                        return TRUE;
                    }
                return ERROR;
            case 22:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            case 23:
                r.solveoption=r.NOTAGAIN;
                lib=new program();
                return TRUE;
            case 24:
            case 25:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type!=term.FUNCTOR||t.arity!=0)
                    return ERROR;
                return TRUE;
            case 26:
                r.solveoption=r.NOTAGAIN;
                if(assert(program.gramconvert(rpred.arg[0].copy())
                          ))
                    return TRUE;
                return ERROR;
            case 27:
                r.solveoption=r.NOTAGAIN;
                if(program.asserta(lib.user,
                                   program.gramconvert(rpred.arg[0].copy())
                                   ))
                    return TRUE;
                return ERROR;
            case 28:
                r.solveoption=r.NOTAGAIN;
                return retract(rpred.arg[0]);
            case 29:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            case 30:
                r.solveoption=r.NOTAGAIN;
                term nam=term.skipeq(rpred.arg[2]);
                if(nam.type!=term.FUNCTOR||nam.arity!=0)
                    return ERROR;
                term ty=term.skipeq(rpred.arg[1]);
                if(ty.type!=term.FUNCTOR||ty.arity!=0)
                    return ERROR;
                if(prologop.addoperator(nam.name,ty.name,
                                        term.numbervalue(rpred.arg[0])))
                    return TRUE;
                return ERROR;
            case 31:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type==term.OPEN)
                    return TRUE;
                return FALSE;
            case 32:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type!=term.OPEN)
                    return TRUE;
                return FALSE;
            case 33:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type==term.FUNCTOR&&t.arity==0)
                    return TRUE;
                return FALSE;
            case 34:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type==term.NUMBER)
                    return TRUE;
                return FALSE;
            case 35:
                r.solveoption=r.NOTAGAIN;
                term left=term.skipeq(rpred.arg[0]);
                if(left.type==term.FUNCTOR)
                    {
                        term tail=term.emptylist;
                        for(int i=left.arity-1;i>=0;i--)
                            tail=term.makelist(left.arg[i],tail);
                        term head=term.newconstant(left.name,left.qname);
                        if(term.match(term.makelist(head,tail),rpred.arg[1],subst))
                            return TRUE;
                        return FALSE;
                    }
                term right=term.skipeq(rpred.arg[1]);
                if(right.type==term.FUNCTOR&&right.name==prologop.listcons.name)
                    {
                        term h=term.skipeq(right.arg[0]);
                        if(h.type==term.FUNCTOR&&h.arity==0)
                            {t=term.newconstant(h.name,h.qname);
                            l=term.skipeq(right.arg[1]);
                            while(l!=term.emptylist)
                                {
                                    if(t.arity==term.MAXARG||l.type!=term.FUNCTOR
                                       ||l.name!=prologop.listcons.name)
                                        return ERROR;
                                    t.addarg(term.skipeq(l.arg[0]));
                                    l=term.skipeq(l.arg[1]);
                                }
                            if(term.match(left,t,subst))
                                return TRUE;
                            return FALSE;
                            }
                    }
                return ERROR;
            case 36:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type==term.FUNCTOR&&t.arity==0)
                    {if(term.match(rpred.arg[1],term.asciilist(t.name),subst))
                        return TRUE;
                    return FALSE;
                    }
                String str=term.readasciilist(rpred.arg[1]);
                if(str!=null&&term.match(rpred.arg[0],term.newconstant(str),subst))
                    return TRUE;
                return FALSE;
            case 37:
                r.solveoption=r.NOTAGAIN;
                if(term.equal(rpred.arg[0],rpred.arg[1]))
                    return TRUE;
                else
                    return FALSE;
            case 38:
                if(r.solveoption==r.UNKNOWN)
                    {r.solveoption=r.BUILTIN;
                    stacktodo(rpred.arg[0],r);
                    return TRUE;
                    }
                r.solveoption=r.NOTAGAIN;
                stacktodo(rpred.arg[1],r);
                return TRUE;
            case 39:
                r.solveoption=r.NOTAGAIN;
                stacktodo(rpred.arg[1],r);
                stacktodo(rpred.arg[0],r);
                return TRUE;
            case 40:
                r.solveoption=r.NOTAGAIN;
                t=term.skipeq(rpred.arg[0]);
                if(t.type==term.FUNCTOR&&t.arity>0)
                    return TRUE;
                return FALSE;
            case 41:
                r.solveoption=r.NOTAGAIN;
                int a=term.numbervalue(rpred.arg[0]);
                int b=term.numbervalue(rpred.arg[1]);
                if(a<=b&&a!=term.NaN&&b!=term.NaN)
                    {
                        if(term.match(rpred.arg[2],
                                      new term(a+(int)(Math.random()*(b-a))),
                                      subst))
                            return TRUE;
                        return FALSE;
                    }
                return ERROR;
            case 42:
                r.solveoption=r.NOTAGAIN;
                if(term.equal(rpred.arg[0],rpred.arg[1]))
                    return FALSE;
                else
                    return TRUE;
            case 43:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            case 44:
                r.solveoption=r.NOTAGAIN;
                return TRUE;
            default:
                System.out.println("bipred missing.");
                return ERROR;
            }}//OD switch, OD bi!=-1
        if(rpred==ASK)
            {
                if(uservars.size()==0)
                    return TRUE;
                substwrite();
                return FALSE;
            }
        /*No builtin predicate. Get a fitting rule out the
          clause lib, match the head, and stack the body.*/
        if(r.solveoption==r.UNKNOWN) {
            r.clauses=lib.get(rpred);
            if(r.clauses==null) {
                System.out.println("undefined predicate: "+lib.searchkey(rpred));
                return FALSE;
            }
        }
        else if(r.clauses!=term.emptylist)
            r.clauses=r.clauses.arg[1];
        r.solveoption=1;
        term theclause;
        while(r.clauses!=term.emptylist) {
            theclause=r.clauses.arg[0].copy();
            if(term.match(rpred,lib.head(theclause),subst)) {
                stacktodo(lib.body(theclause),r);
                return TRUE;
            }
            r.clauses=r.clauses.arg[1];
        }
        return FALSE;
    }

    public void run(int max_iter) {
        rack current;
        wait=false;
        int substnum;

        int iter = 0;
        while(iter++ < max_iter) {
            if(todo.size()==0) {
                System.out.println("\nyes");
                return;
            }
            current=(rack)todo.pop();
            int v=solve(current);
            if(v==ERROR) {
                do {
                    System.out.println("Error in: "+current.pred);
                    current=current.parent;
                } while(current!=null);
                return;
            }
            else if(v==TRUE) {
                current.substdone=subst.size();
                done.push(current);
            } else {//v==FALSE
                current.solveoption=rack.UNKNOWN;
                todo.push(current);
                if(done.isEmpty())  return;
                current=(rack)done.pop();
                while(((rack)todo.peek()).parent==current)
                    {todo.pop();}
                todo.push(current);
                if(!done.isEmpty())
                    substnum=((rack)done.peek()).substdone;
                else
                    substnum=0;
                term.unmatch(subst,substnum);
            }
        }
    }

    term executepred(term X) {
        /*returns A if X == (:-A), or null.*/
        if(X==null)
            return null;
        X=term.skipeq(X);
        if(X.type==term.FUNCTOR&&X.arity==1&&X.name.equals(":-"))
            return X.arg[0];
        return null;
    }

    boolean assert(term X)
    {  return program.assert(lib.user,X);
    }

    int retract(term t) {
        term list=lib.get(t);
        if(list==null||list==term.emptylist)
            return FALSE;
        if(term.match(t,lib.head(list.arg[0]),subst)) {
            lib.user.put(lib.searchkey(t),list.arg[1]);
            return TRUE;
        }
        term superlist=list;
        list=list.arg[1];
        while(list!=term.emptylist) {
            if(term.match(t,list.arg[0],subst)) {
                superlist.arg[1]=list.arg[1];
                return TRUE;
            }
            superlist=list;
            list=list.arg[1];
        }
        return FALSE;
    }

    void substwrite() {
        term g;
        StringBuffer buf=new StringBuffer("\n");
        Hashtable hash = new Hashtable();
        for(int i=0;i<uservars.size();i++) {
            g=(term)uservars.elementAt(i);
            String rightside=""+g;
            String leftside=g.varname();
            if(!leftside.equals("_")&&!leftside.equals(rightside)) {
                hash.put(leftside, rightside);
            }
        }
        answers.addElement(hash);
    }

    Vector answers = new Vector();
    Vector getAnswers() {
        Vector ret = answers;
        answers = new Vector(); // clear for next time
        return ret;
    }
}