|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectubc.cs.JLog.Foundation.jType
ubc.cs.JLog.Terms.jTerm
ubc.cs.JLog.Terms.jCompoundTerm
public class jCompoundTerm
This class represents a collection of terms.
Field Summary | |
---|---|
protected java.util.Vector |
terms
|
Fields inherited from class ubc.cs.JLog.Foundation.jType |
---|
type |
Fields inherited from interface ubc.cs.JLog.Terms.iTerm |
---|
EQUAL, GREATER_THAN, LESS_THAN |
Fields inherited from interface ubc.cs.JLog.Foundation.iType |
---|
TYPE_ARITHMETIC, TYPE_ATOM, TYPE_BUILTINPREDICATE, TYPE_COMMAND, TYPE_COMPARE, TYPE_COMPOUND, TYPE_CONS, TYPE_IF, TYPE_INTEGER, TYPE_LIST, TYPE_NULLLIST, TYPE_NUMERICCOMPARE, TYPE_OBJECT, TYPE_OPERATOR, TYPE_OR, TYPE_ORPREDICATE, TYPE_PREDICATE, TYPE_PREDICATETERMS, TYPE_REAL, TYPE_TYPE, TYPE_UNARYARITHMETIC, TYPE_UNARYOPERATOR, TYPE_UNDEFINED, TYPE_VARIABLE |
Constructor Summary | |
---|---|
jCompoundTerm()
|
|
jCompoundTerm(int initialCapacity)
|
|
jCompoundTerm(java.util.Vector t)
|
Method Summary | |
---|---|
void |
addTerm(jTerm t)
|
int |
compare(jTerm term,
boolean first_call,
boolean var_equal)
The private member function for term comparision. |
void |
consult(jKnowledgeBase kb)
Consult the given jKnowledgeBase and cache any invariant values (those
which would not change until the next time the jKnowledgeBase changes). |
void |
consultReset()
Called when the jKnowledgeBase changes. |
jTerm |
copy(jVariableRegistry vars)
Internal member function which creates a copy of this term. |
void |
copyCompoundTerm(jCompoundTerm ct)
Makes this a copy of the provided jCompoundTerm . |
jTerm |
duplicate(jVariable[] vars)
Creates a complete and entirely independant duplicate of this term. |
jTerm |
elementAt(int index)
|
void |
enumerateVariables(jVariableVector v,
boolean all)
Adds variables belonging to this term (or belonging to any sub-part of this term) to the jVariableVector |
java.util.Enumeration |
enumTerms()
|
boolean |
equivalence(jTerm term,
jEquivalenceMapping v)
The public interface for evaluating term equivalence (i.e., structural similarity). |
protected java.lang.String |
getEndingSymbol()
|
protected java.lang.String |
getStartingSymbol()
|
boolean |
hasTerm(jTerm t)
|
java.util.Vector |
internal_copy(jVariableRegistry vars)
|
protected java.util.Vector |
internal_duplicate(jVariable[] vars)
|
void |
intersectionCompoundTerm(jCompoundTerm ct)
Adds all jTerms in given jCompoundTerm
to this. |
boolean |
isEmpty()
|
protected boolean |
isHigherPriorityOperator(jTerm t)
Determines if provided jTerm is of higher priority than ','. |
void |
make(jTerm t)
Makes this a representation of the provided jTerm . |
void |
makeCompoundTerm(jTerm t)
Add jCons separated jTerm s to this
jCompoundTerm . |
void |
mutateElementAt(int index,
jTerm term)
Mutates a term element in the compount term. |
void |
registerUnboundVariables(jUnifiedVector v)
Adds any unbound variables belonging to this term (or belonging to any sub-part of this term) to the jUnifiedVector |
void |
registerVariables(jVariableVector v)
Adds all variables belonging to this term (or belonging to any sub-part of this term) to the jUnifiedVector
Should be called during the consultation phase by rules for their owned terms
both head and base. |
void |
removeAllTerms()
|
void |
removeTerm(jTerm t)
|
boolean |
requiresCompleteVariableState()
Call to determine if enclosing rule should record all variable states. |
int |
size()
|
void |
subtractCompoundTerm(jCompoundTerm ct)
Removes all jTerms in given jCompoundTerm
from this. |
java.lang.String |
toString(boolean usename)
Produces a string identifying this term, suitable for display to the console. |
boolean |
unify(jTerm term,
jUnifiedVector v)
Determines if this instance and term unify. |
void |
unionCompoundTerm(jCompoundTerm ct)
Removes all jTerms not in given jCompoundTerm
from this. |
jTerm |
unmake()
Creates a jCons separated jTerm s to
represent this jCompoundTerm . |
jTerm |
unmakeCompoundTerm()
Creates a jCons separated jTerm s to
represent this jCompoundTerm . |
Methods inherited from class ubc.cs.JLog.Terms.jTerm |
---|
compare, copy, getName, getTerm, getValue, isConsultNeeded, toString |
Methods inherited from class ubc.cs.JLog.Foundation.jType |
---|
getType, objectToString |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Field Detail |
---|
protected java.util.Vector terms
Constructor Detail |
---|
public jCompoundTerm()
public jCompoundTerm(int initialCapacity)
public jCompoundTerm(java.util.Vector t)
Method Detail |
---|
public int compare(jTerm term, boolean first_call, boolean var_equal)
jTerm
jTerm
. sub-classes must override.
compare
in class jTerm
term
- the jTerm
to compare with this instance of
jTerm
. if
term
is an unknown type then, if
first_call
is
true
, call term.compare(this,false) and return
the negative result, otherwise return EQUAL
.first_call
- true
if just invoked by public
compare
member function.
false
otherwise.var_equal
- if var_equal
is true
, then unbound
variables are considered equal.
var_equal
= false
is standard prolog
behavior.
LESS_THAN
if this instance is less than
term
,
EQUAL
if the two terms are equal, and
GREATER_THAN
if
this instance is greater than term
.public final boolean hasTerm(jTerm t)
public void addTerm(jTerm t)
public void removeTerm(jTerm t)
public void removeAllTerms()
public final java.util.Enumeration enumTerms()
public final int size()
public final jTerm elementAt(int index)
public void mutateElementAt(int index, jTerm term)
index
- The zero-based index of the element to mutate.term
- The term to make the new element at index.public final boolean isEmpty()
public boolean requiresCompleteVariableState()
jTerm
cut
, which jump back to the
containing rules goal require that all variables are restored.
requiresCompleteVariableState
in interface iTerm
requiresCompleteVariableState
in class jTerm
true
if all variable bindings must be recorded by
the rule containing this term. false
otherwise.
Normally returns false
public void registerUnboundVariables(jUnifiedVector v)
jTerm
jUnifiedVector
registerUnboundVariables
in interface iTerm
registerUnboundVariables
in class jTerm
v
- The jUnifiedVector
where unbound variables are
added to. This parameter is used to as output to the caller, not as input.public boolean equivalence(jTerm term, jEquivalenceMapping v)
iTerm
equivalence
in interface iTerm
equivalence
in class jTerm
term
- the jTerm
to compare with this instance of
jTerm
.v
- v
is the collection of equivalent variable pairs found.
It should be empty when first calling this function.
true
if this instance is equivalent to term
,
false
otherwise.public boolean unify(jTerm term, jUnifiedVector v)
iUnifiable
term
unify.
Every variable which was previously unbound, but which becomes bound during
the unification must register itself with the jUnifiedVector
. It
is the callers responsibility to deal with the unified vector.
unify
in interface iUnifiable
unify
in interface iTerm
unify
in class jTerm
term
- the term to unify with this instance.v
- the vector of variables bound during unification. Even if
unification fails, this vector may contain recently
bound vectors. This parameter is used to as output to the
caller, not as input for unify
.
true
if unification succeeded,
false
otherwise.public void registerVariables(jVariableVector v)
jTerm
jUnifiedVector
Should be called during the consultation phase by rules for their owned terms
both head and base. all variables encountered should be unbound.
After call, this term should not be modified in any way.
registerVariables
in interface iTerm
registerVariables
in class jTerm
v
- The jUnifiedVector
where variables are
added to. This parameter is used to as output to the
caller, not as input.public void enumerateVariables(jVariableVector v, boolean all)
jTerm
jVariableVector
enumerateVariables
in interface iTerm
enumerateVariables
in class jTerm
v
- The jVariabeVector
where variables are
added to. This parameter is used to as output to the
caller, not as input.all
- If true
, then all variables should register,
otherwise only add non-existentially qualified variables.public jTerm duplicate(jVariable[] vars)
jTerm
registerVariables
has already been
invoked.
Within duplicate
, any other calls to duplicate should pass along
the same vars
array produced by registerVariables
since the same duplication path previously taken by registerVariables
should be taken by duplicate
. This call is designed only for terms
which belong to rules and are templates for instantiation. Any variables in the
term should be unbound. As implied by the modification restrictions on
registerVariables
, terms and their children cannot change
(especially during call!)
duplicate
in interface iTerm
duplicate
in class jTerm
vars
- The user passes in a duplicate of the variable vector produced
from the previous call to registerVariables
.
vars
is produced from the
jVariableVector
by creating a single duplicate
variable for each variable. Since this is created in the same
order as the registerVariables
, it is now
efficient for jVariables
to return their
unique duplicate.
jTerm
which is an instantiated duplicate of this
term.protected java.util.Vector internal_duplicate(jVariable[] vars)
public jTerm copy(jVariableRegistry vars)
jTerm
duplicate
function. Should only be invoked by copy()
or other copy(vars)
. Should only invoke other
copy(vars)
functions.
Bound variables should return a copy of the bound term.
copy
in interface iTerm
copy
in class jTerm
vars
- The registry of variables and their duplicates. Initially this
is empty. As variables generate copies, they add themselves
and their copy to the jVariableRegistry
, and this
is output from the function call. Any further calls with the
same vars
ensures that the same variable
(in a different term) returns the same copy.
jTerm
which is an instantiated copy of this
term.public java.util.Vector internal_copy(jVariableRegistry vars)
public void copyCompoundTerm(jCompoundTerm ct)
jCompoundTerm
.
ct
- jCompoundTerm
to duplicate.public void subtractCompoundTerm(jCompoundTerm ct)
jTerms
in given jCompoundTerm
from this.
ct
- jCompoundTerm
with terms to remove.public void unionCompoundTerm(jCompoundTerm ct)
jTerms
not in given jCompoundTerm
from this.
ct
- jCompoundTerm
with terms to keep.public void intersectionCompoundTerm(jCompoundTerm ct)
jTerms
in given jCompoundTerm
to this.
ct
- jCompoundTerm
with terms to add.public void make(jTerm t)
jTerm
. Invokes
makeCompoundTerm
.
make
in interface iMakeUnmake
t
- jTerm
using jCons
to separate
terms.public void makeCompoundTerm(jTerm t)
jCons
separated jTerm
s to this
jCompoundTerm
.
t
- jTerm
using jCons
to separate
terms.public jTerm unmake()
jCons
separated jTerm
s to
represent this jCompoundTerm
. Invokes
unmakeCompoundTerm
to perform work.
unmake
in interface iMakeUnmake
jTerm
using jCons
to separate
terms. Duplicates this jCompoundTerm
public jTerm unmakeCompoundTerm()
jCons
separated jTerm
s to
represent this jCompoundTerm
.
jTerm
using jCons
to separate
terms. Duplicates this jCompoundTerm
public void consult(jKnowledgeBase kb)
iConsultable
jKnowledgeBase
and cache any invariant values (those
which would not change until the next time the jKnowledgeBase
changes).
Where possible, consultable objects should minimize computation and assume that any
cached values are still accurate.
consult
in interface iConsultable
consult
in interface iTerm
consult
in class jTerm
kb
- the knowledge base which attempted proofs are based upon.public void consultReset()
iConsultable
jKnowledgeBase
changes. Should set all cached values to
dirty so that a following call to consult
would perform a full lookup
as required.
consultReset
in interface iConsultable
consultReset
in interface iTerm
consultReset
in class jTerm
public java.lang.String toString(boolean usename)
jTerm
false
is the default for displaying the term,
true
for displaying this term in a user query.
toString
in interface iTerm
toString
in class jTerm
String
which is a textual representation of this
term.protected java.lang.String getStartingSymbol()
protected java.lang.String getEndingSymbol()
protected boolean isHigherPriorityOperator(jTerm t)
jTerm
is of higher priority than ','.
t
- The jTerm
to evaluate.
true
if jTerm
is a builtin operator
with higher priority than the ',' operator, false
otherwise.
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |