Modifier and Type | Method and Description |
---|---|
abstract QueryProposition |
QueryProposition.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Returns a new query proposition of the same type, in which all variables in
inner formulas and actions are replaced according to the given map.
|
abstract QueryProposition |
QueryProposition.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Returns a new query proposition of the same type, in which all variables in
inner formulas and actions are replaced according to the given map.
|
QueryProposition |
NecessarilyQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
QueryProposition |
NecessarilyQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
QueryProposition |
HoldsQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
QueryProposition |
HoldsQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
QueryProposition |
AlwaysQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
QueryProposition |
AlwaysQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
Modifier and Type | Method and Description |
---|---|
FolAction |
FolAction.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes terms in all non-zero-arity atoms in this action according to
the given map.
|
FolAction |
FolAction.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes terms in all non-zero-arity atoms in this action according to
the given map.
|
Modifier and Type | Field and Description |
---|---|
private static java.util.List<Term<?>> |
TestArguments.TINA |
Modifier and Type | Method and Description |
---|---|
Term |
DelpParser.Term(DefeasibleLogicProgram delp,
FolSignature signature) |
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
DelpRule.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term<?>> |
DelpRule.getTerms() |
Modifier and Type | Method and Description |
---|---|
RelationalFormula |
StrictRule.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
StrictRule.substitute(Term<?> v,
Term<?> t) |
abstract RelationalFormula |
DelpRule.substitute(Term<?> v,
Term<?> t) |
abstract RelationalFormula |
DelpRule.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
DelpFact.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
DelpFact.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
DefeasibleRule.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
DefeasibleRule.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
java.util.List<? extends Term<?>> |
LdoArgument.getArguments() |
Modifier and Type | Method and Description |
---|---|
void |
LdoArgument.addArgument(Term<?> arg) |
Modifier and Type | Class and Description |
---|---|
class |
Constant
A Constant represents an constant object in the world of
a logical language.
|
class |
FunctionalTerm
A functional term in a logic language, i.e.
|
class |
NumberTerm
This is a term representing an integer number it is used
to distinguish between objects like an auto a which is
modeled as constant and integral numbers like 42.
|
class |
StringTerm
This class represents terms which are objects identified by a
string.
|
class |
TermAdapter<T>
Abstract base class implementing the substitute(), getSort(), getTerms(), and
containsTermsOfType() methods in a way it is useful for terms.
|
class |
Variable
A Variable is a placeholder for Constants in a generic formula of
an logic language.
|
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
TermAdapter.containsTermsOfType(java.lang.Class<C> cls) |
<C extends Term<?>> |
Sort.containsTermsOfType(java.lang.Class<C> cls) |
<C extends Term<?>> |
ComplexLogicalFormulaAdapter.containsTermsOfType(java.lang.Class<C> cls) |
<C extends Term<?>> |
TermAdapter.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
Sort.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
FunctionalTerm.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
ComplexLogicalFormulaAdapter.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
AssociativeFormulaSupport.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
Term<?> |
TermAdapter.substitute(Term<?> v,
Term<?> t) |
Term<?> |
FunctionalTerm.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
java.util.List<Term<?>> |
FunctionalTerm.getArguments() |
java.util.Set<Term<?>> |
TermAdapter.getTerms() |
java.util.Set<Term<?>> |
Sort.getTerms() |
java.util.Set<Term<?>> |
FunctionalTerm.getTerms() |
java.util.Set<Term<?>> |
AssociativeFormulaSupport.getTerms() |
static java.util.Map<Sort,java.util.Set<Term<?>>> |
Sort.sortTerms(java.util.Collection<? extends Term<?>> terms)
Sorts the set of given terms by their sorts, i.e.
|
Modifier and Type | Method and Description |
---|---|
void |
Sort.add(Term<?> term)
Adds the given term to this sort.
|
FunctionalTerm |
FunctionalTerm.addArgument(Term<?> term)
Appends the given argument to this term's
arguments and returns itself.
|
ComplexLogicalFormula |
ComplexLogicalFormulaAdapter.exchange(Term<?> v,
Term<?> t) |
ComplexLogicalFormula |
ComplexLogicalFormulaAdapter.exchange(Term<?> v,
Term<?> t) |
boolean |
Sort.remove(Term<?> term)
Removes the given term from this sort.
|
Term<?> |
TermAdapter.substitute(Term<?> v,
Term<?> t) |
Term<?> |
TermAdapter.substitute(Term<?> v,
Term<?> t) |
Term<?> |
FunctionalTerm.substitute(Term<?> v,
Term<?> t) |
Term<?> |
FunctionalTerm.substitute(Term<?> v,
Term<?> t) |
ComplexLogicalFormula |
AssociativeFormulaSupport.substitute(Term<?> v,
Term<?> t) |
ComplexLogicalFormula |
AssociativeFormulaSupport.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
static java.util.Map<Sort,java.util.Set<Term<?>>> |
Sort.sortTerms(java.util.Collection<? extends Term<?>> terms)
Sorts the set of given terms by their sorts, i.e.
|
ComplexLogicalFormula |
ComplexLogicalFormulaAdapter.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
ComplexLogicalFormula |
ComplexLogicalFormulaAdapter.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
Constructor and Description |
---|
FunctionalTerm(Functor functor,
Term<?>... terms) |
Constructor and Description |
---|
FunctionalTerm(Functor functor,
java.util.List<Term<?>> arguments)
Creates a new functional term with the given functor and the given list
of arguments.
|
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
LogicStructure.containsTermsOfType(java.lang.Class<C> cls)
Checks if this logical structure contains at least one term of type C.
|
<C extends Term<?>> |
LogicStructure.getTerms(java.lang.Class<C> cls)
Processes the set containing all terms of type C.
|
Modifier and Type | Method and Description |
---|---|
Term<?> |
Term.clone()
Creates a deep copy of the term
|
Term<?> |
Term.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this term
by term "t" and returns the new term.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<? extends Term<?>> |
Atom.getArguments() |
java.util.Set<Term<?>> |
LogicStructure.getTerms() |
Modifier and Type | Method and Description |
---|---|
void |
Atom.addArgument(Term<?> arg)
Adds an argument to the atom's argument list
|
LogicProgram<?,?,?> |
LogicProgram.exchange(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and at the same time replaces all occurrences of term "t"
by term "v" and eventually returns the new formula.
|
LogicProgram<?,?,?> |
LogicProgram.exchange(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and at the same time replaces all occurrences of term "t"
by term "v" and eventually returns the new formula.
|
ComplexLogicalFormula |
ComplexLogicalFormula.exchange(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and at the same time replaces all occurrences of term "t"
by term "v" and eventually returns the new formula.
|
ComplexLogicalFormula |
ComplexLogicalFormula.exchange(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and at the same time replaces all occurrences of term "t"
by term "v" and eventually returns the new formula.
|
Term<?> |
Term.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this term
by term "t" and returns the new term.
|
Term<?> |
Term.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this term
by term "t" and returns the new term.
|
LogicProgram<?,?,?> |
LogicProgram.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and returns the new formula.
|
LogicProgram<?,?,?> |
LogicProgram.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and returns the new formula.
|
ComplexLogicalFormula |
ComplexLogicalFormula.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and returns the new formula.
|
ComplexLogicalFormula |
ComplexLogicalFormula.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and returns the new formula.
|
Modifier and Type | Method and Description |
---|---|
static Atom.RETURN_SET_PREDICATE |
Atom.AtomImpl.implSetPredicate(Predicate old,
Predicate newer,
java.util.List<Term<?>> arguments) |
LogicProgram<?,?,?> |
LogicProgram.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes all occurrences of all terms "v" in map.keyset() in this formula
by map.get(v) and returns the new formula.
|
LogicProgram<?,?,?> |
LogicProgram.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes all occurrences of all terms "v" in map.keyset() in this formula
by map.get(v) and returns the new formula.
|
ComplexLogicalFormula |
ComplexLogicalFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes all occurrences of all terms "v" in map.keyset() in this formula
by map.get(v) and returns the new formula.
|
ComplexLogicalFormula |
ComplexLogicalFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes all occurrences of all terms "v" in map.keyset() in this formula
by map.get(v) and returns the new formula.
|
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
ModalFormula.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term<?>> |
ModalFormula.getTerms() |
Modifier and Type | Method and Description |
---|---|
RelationalFormula |
Possibility.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
Possibility.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
Necessity.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
Necessity.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
ModalFormula.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
ModalFormula.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
Term<?> |
FolParserB.term(FolSignature signature,
Sort type) |
Modifier and Type | Method and Description |
---|---|
private java.util.List<Term<?>> |
FolParser.parseTermlist(java.util.List<java.lang.Object> l)
Parses a term list as a list of String tokens or terms into a list of terms.
|
Modifier and Type | Method and Description |
---|---|
private Functor |
FolParserB.getOrCreateFunctor(java.lang.String name,
java.util.List<Term<?>> args,
Sort targetSort,
FolSignature signature) |
Modifier and Type | Method and Description |
---|---|
HerbrandInterpretation |
HerbrandInterpretation.exchange(Term<?> t1,
Term<?> t2)
Substitutes every occurrence of "t1" by "t2" and vice versa and returns the
new interpretation.
|
HerbrandInterpretation |
HerbrandInterpretation.exchange(Term<?> t1,
Term<?> t2)
Substitutes every occurrence of "t1" by "t2" and vice versa and returns the
new interpretation.
|
Modifier and Type | Method and Description |
---|---|
HerbrandInterpretation |
HerbrandInterpretation.exchange(java.util.Map<Term<?>,Term<?>> mapping)
For every mapping t1 -> t2, this method substitutes every
occurrence of "t1" by "t2" and vice versa and returns the new interpretation
|
HerbrandInterpretation |
HerbrandInterpretation.exchange(java.util.Map<Term<?>,Term<?>> mapping)
For every mapping t1 -> t2, this method substitutes every
occurrence of "t1" by "t2" and vice versa and returns the new interpretation
|
private java.util.Set<FOLAtom> |
HerbrandBase.getAllInstantiations(FolSignature sig,
Predicate p,
java.util.List<Term<?>> arguments)
Computes all instantiations of the predicate "p" relative to the signature "sig"
where "arguments" defines the first arguments of the atoms.
|
Modifier and Type | Field and Description |
---|---|
private java.util.List<Term<?>> |
FOLAtom.arguments
The arguments of the atom
|
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
RelationalFormula.containsTermsOfType(java.lang.Class<C> cls) |
<C extends Term<?>> |
SpecialFormula.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
QuantifiedFormula.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
Negation.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
FOLAtom.getTerms(java.lang.Class<C> cls) |
<C extends Term<?>> |
AssociativeFOLFormula.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<java.util.Map<Variable,Term<?>>> |
RelationalFormula.allSubstitutions(java.util.Collection<? extends Term<?>> terms)
Computes all possible substitutions, i.e.
|
java.util.List<Term<?>> |
FOLAtom.getArguments() |
java.util.Set<Term<?>> |
SpecialFormula.getTerms() |
java.util.Set<Term<?>> |
QuantifiedFormula.getTerms() |
java.util.Set<Term<?>> |
Negation.getTerms() |
java.util.Set<Term<?>> |
FOLAtom.getTerms() |
java.util.Set<Term<?>> |
AssociativeFOLFormula.getTerms() |
Modifier and Type | Method and Description |
---|---|
void |
FOLAtom.addArgument(Term<?> term)
Appends the given argument to this atom's
arguments and returns itself.
|
RelationalFormula |
RelationalFormula.exchange(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and at the same time replaces all occurrences of term "t"
by term "v" and eventually returns the new formula.
|
RelationalFormula |
RelationalFormula.exchange(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and at the same time replaces all occurrences of term "t"
by term "v" and eventually returns the new formula.
|
FolFormula |
SpecialFormula.substitute(Term<?> v,
Term<?> t) |
FolFormula |
SpecialFormula.substitute(Term<?> v,
Term<?> t) |
abstract RelationalFormula |
RelationalFormula.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and returns the new formula.
|
abstract RelationalFormula |
RelationalFormula.substitute(Term<?> v,
Term<?> t)
Substitutes all occurrences of term "v" in this formula
by term "t" and returns the new formula.
|
Negation |
Negation.substitute(Term<?> v,
Term<?> t) |
Negation |
Negation.substitute(Term<?> v,
Term<?> t) |
ForallQuantifiedFormula |
ForallQuantifiedFormula.substitute(Term<?> v,
Term<?> t) |
ForallQuantifiedFormula |
ForallQuantifiedFormula.substitute(Term<?> v,
Term<?> t) |
abstract FolFormula |
FolFormula.substitute(Term<?> v,
Term<?> t) |
abstract FolFormula |
FolFormula.substitute(Term<?> v,
Term<?> t) |
FOLAtom |
FOLAtom.substitute(Term<?> v,
Term<?> t) |
FOLAtom |
FOLAtom.substitute(Term<?> v,
Term<?> t) |
ExistsQuantifiedFormula |
ExistsQuantifiedFormula.substitute(Term<?> v,
Term<?> t) |
ExistsQuantifiedFormula |
ExistsQuantifiedFormula.substitute(Term<?> v,
Term<?> t) |
Conjunction |
Conjunction.substitute(Term<?> v,
Term<?> t) |
Conjunction |
Conjunction.substitute(Term<?> v,
Term<?> t) |
AssociativeFOLFormula |
AssociativeFOLFormula.substitute(Term<?> v,
Term<?> t) |
AssociativeFOLFormula |
AssociativeFOLFormula.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<java.util.Map<Variable,Term<?>>> |
RelationalFormula.allSubstitutions(java.util.Collection<? extends Term<?>> terms)
Computes all possible substitutions, i.e.
|
RelationalFormula |
RelationalFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes all occurrences of all terms "v" in map.keyset() in this formula
by map.get(v) and returns the new formula.
NOTE: variables bound to quantifiers are not substituted in their inner formulas even if they appear in the map. |
RelationalFormula |
RelationalFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Substitutes all occurrences of all terms "v" in map.keyset() in this formula
by map.get(v) and returns the new formula.
NOTE: variables bound to quantifiers are not substituted in their inner formulas even if they appear in the map. |
AssociativeFOLFormula |
AssociativeFOLFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> termMap) |
AssociativeFOLFormula |
AssociativeFOLFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> termMap) |
Constructor and Description |
---|
FOLAtom(Predicate predicate,
Term<?>... terms) |
Constructor and Description |
---|
FOLAtom(Predicate predicate,
java.util.List<? extends Term<?>> arguments)
Creates a new atom with the given predicate and list of
terms
|
Modifier and Type | Method and Description |
---|---|
private java.lang.String |
AlchemyMlnReasoner.alchemyStringForTerm(Term<?> t)
Returns the string in Alchemy syntax representing the given term.
|
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
MlnFormula.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term<?>> |
MlnFormula.getTerms() |
Modifier and Type | Method and Description |
---|---|
RelationalFormula |
MlnFormula.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
MlnFormula.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
java.util.List<? extends Term<?>> |
Proposition.getArguments() |
Modifier and Type | Method and Description |
---|---|
void |
Proposition.addArgument(Term<?> arg) |
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
RelationalConditional.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term<?>> |
RelationalConditional.getTerms() |
Modifier and Type | Method and Description |
---|---|
RelationalFormula |
RelationalConditional.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
RelationalConditional.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
DefaultRule.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term<?>> |
DefaultRule.getTerms() |
Modifier and Type | Method and Description |
---|---|
RelationalFormula |
DefaultRule.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
DefaultRule.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
RpclBeliefSet |
RpclBeliefSet.exchange(Term<?> a,
Term<?> b)
Exchanges every occurence of "a" by "b" and vice versa.
|
RpclBeliefSet |
RpclBeliefSet.exchange(Term<?> a,
Term<?> b)
Exchanges every occurence of "a" by "b" and vice versa.
|
Modifier and Type | Method and Description |
---|---|
RelationalFormula |
RelationalProbabilisticConditional.substitute(Term<?> v,
Term<?> t) |
RelationalFormula |
RelationalProbabilisticConditional.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
Term<?> |
InstantiateVisitor.visit(ASTArithmeticInteger node,
java.lang.Object data) |
Term<?> |
InstantiateVisitor.visit(ASTListTail node,
java.lang.Object data) |
Term<?> |
InstantiateVisitor.visit(ASTSimpleTerm node,
java.lang.Object data) |
Term<?> |
InstantiateVisitor.visit(ASTTerm node,
java.lang.Object data) |
Modifier and Type | Method and Description |
---|---|
java.util.List<Term<?>> |
InstantiateVisitor.visit(ASTTermLst node,
java.lang.Object data) |
Modifier and Type | Method and Description |
---|---|
private void |
ParserTest.testSet(java.util.Set<Term<?>> set,
InstantiateVisitor visitor) |
Modifier and Type | Class and Description |
---|---|
class |
ListTerm
this class models a list term that can be used for
dlv complex programs.
|
class |
SetTerm
this class models a set term, which can be used
for sets in dlv complex programs.
|
Modifier and Type | Field and Description |
---|---|
private Term<?> |
ListTermValue.head |
private Term<?> |
Comparative.left |
private Term<?> |
Arithmetic.left
the term X on the left of an arithmetic expression: Z=X+Y or the first
argument of an build-in function #func(X,Y,Z)
|
protected Term<?> |
Aggregate.leftGuard |
private Term<?> |
Arithmetic.result
the term Z giving the result of the arithmetic expression: Z=X+Y or the third
argument of an build-in function #func(X,Y,Z)
|
private Term<?> |
Comparative.right |
private Term<?> |
Arithmetic.right
the term Y on the right of the arithmetic expression: Z=X+Y or the second
argument of an build-in function #func(X,Y,Z)
|
protected Term<?> |
Aggregate.rightGuard |
private Term<?> |
ListTermValue.tail |
Modifier and Type | Field and Description |
---|---|
protected java.util.List<Term<?>> |
DLPAtom.arguments
a list of arguments of the atom
|
private java.util.List<Term<?>> |
ListTermValue.list |
Modifier and Type | Method and Description |
---|---|
Term<?> |
Arithmetic.getLeftArgument() |
Term<?> |
Aggregate.getLeftGuard() |
Term<?> |
Comparative.getLefthand() |
Term<?> |
Arithmetic.getResult() |
Term<?> |
Arithmetic.getRightArgument() |
Term<?> |
Aggregate.getRightGuard() |
Term<?> |
Comparative.getRighthand() |
Term<?> |
DLPAtom.getTerm(int index) |
Term<?> |
ListTermValue.head() |
Term<?> |
ListTermValue.tail() |
Modifier and Type | Method and Description |
---|---|
java.util.List<? extends Term<?>> |
DLPNeg.getArguments() |
java.util.List<? extends Term<?>> |
DLPAtom.getArguments() |
java.util.Set<Term<?>> |
Rule.getTerms() |
java.util.Set<Term<?>> |
DLPNot.getTerms() |
java.util.Set<Term<?>> |
DLPNeg.getTerms() |
java.util.Set<Term<?>> |
DLPHead.getTerms() |
java.util.Set<Term<?>> |
DLPAtom.getTerms() |
java.util.Set<Term<?>> |
Comparative.getTerms() |
java.util.Set<Term<?>> |
Arithmetic.getTerms() |
java.util.Set<Term<?>> |
Aggregate.getTerms() |
java.util.List<Term<?>> |
ListTermValue.list() |
Modifier and Type | Method and Description |
---|---|
void |
DLPNeg.addArgument(Term<?> arg) |
void |
DLPAtom.addArgument(Term<?> arg) |
DLPLiteral |
DLPNeg.cloneWithAddedTerm(Term<?> term) |
DLPLiteral |
DLPLiteral.cloneWithAddedTerm(Term<?> term)
Creates a copy of the literal and adds the
given term as argument to the end of the argument
list.
|
DLPAtom |
DLPAtom.cloneWithAddedTerm(Term<?> tval) |
Program |
Program.exchange(Term<?> v,
Term<?> t) |
Program |
Program.exchange(Term<?> v,
Term<?> t) |
void |
Aggregate.setLeftGuard(Term<?> guard,
java.lang.String rel) |
void |
Aggregate.setRightGuard(Term<?> guard,
java.lang.String rel) |
Rule |
Rule.substitute(Term<?> v,
Term<?> t) |
Rule |
Rule.substitute(Term<?> v,
Term<?> t) |
Program |
Program.substitute(Term<?> v,
Term<?> t) |
Program |
Program.substitute(Term<?> v,
Term<?> t) |
DLPNot |
DLPNot.substitute(Term<?> v,
Term<?> t) |
DLPNot |
DLPNot.substitute(Term<?> v,
Term<?> t) |
DLPNeg |
DLPNeg.substitute(Term<?> v,
Term<?> t) |
DLPNeg |
DLPNeg.substitute(Term<?> v,
Term<?> t) |
DLPLiteral |
DLPLiteral.substitute(Term<?> v,
Term<?> t) |
DLPLiteral |
DLPLiteral.substitute(Term<?> v,
Term<?> t) |
DLPHead |
DLPHead.substitute(Term<?> v,
Term<?> t) |
DLPHead |
DLPHead.substitute(Term<?> v,
Term<?> t) |
DLPElement |
DLPElement.substitute(Term<?> t,
Term<?> v) |
DLPElement |
DLPElement.substitute(Term<?> t,
Term<?> v) |
DLPAtom |
DLPAtom.substitute(Term<?> v,
Term<?> t) |
DLPAtom |
DLPAtom.substitute(Term<?> v,
Term<?> t) |
Comparative |
Comparative.substitute(Term<?> t,
Term<?> v) |
Comparative |
Comparative.substitute(Term<?> t,
Term<?> v) |
Arithmetic |
Arithmetic.substitute(Term<?> t,
Term<?> v) |
Arithmetic |
Arithmetic.substitute(Term<?> t,
Term<?> v) |
Aggregate |
Aggregate.substitute(Term<?> t,
Term<?> v) |
Aggregate |
Aggregate.substitute(Term<?> t,
Term<?> v) |
Modifier and Type | Method and Description |
---|---|
protected java.lang.String |
ListTerm.listPrint(java.util.Collection<Term<?>> tl) |
Program |
Program.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
Program |
Program.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
Constructor and Description |
---|
Aggregate(java.lang.String functor,
SymbolicSet ss,
java.lang.String rightOp,
Term<?> rightGuard) |
Aggregate(Term<?> leftGuard,
java.lang.String leftOp,
java.lang.String functor,
SymbolicSet ss) |
Aggregate(Term<?> leftGuard,
java.lang.String leftOp,
java.lang.String functor,
SymbolicSet ss,
java.lang.String rightOp,
Term<?> rightGuard) |
Aggregate(Term<?> leftGuard,
java.lang.String leftOp,
java.lang.String functor,
SymbolicSet ss,
java.lang.String rightOp,
Term<?> rightGuard) |
Arithmetic(java.lang.String op,
Term<?> left,
Term<?> right,
Term<?> result) |
Arithmetic(java.lang.String op,
Term<?> left,
Term<?> right,
Term<?> result) |
Arithmetic(java.lang.String op,
Term<?> left,
Term<?> right,
Term<?> result) |
Comparative(java.lang.String op,
Term<?> lefthand,
Term<?> righthand) |
Comparative(java.lang.String op,
Term<?> lefthand,
Term<?> righthand) |
DLPAtom(java.lang.String symbol,
Term<?>... terms)
Ctor: Creates an atom with the given predicate as name and the
given terms as argument
|
DLPNeg(java.lang.String symbol,
Term<?>... terms) |
ListTerm(Term<?> head,
Term<?> tail)
constructor for list elements with given [head|tail].
|
ListTerm(Term<?> head,
Term<?> tail)
constructor for list elements with given [head|tail].
|
ListTermValue(Term<?> head,
Term<?> tail) |
ListTermValue(Term<?> head,
Term<?> tail) |
Constructor and Description |
---|
DLPAtom(java.lang.String symbol,
java.util.List<? extends Term<?>> terms)
Creates a predicate for the atom from symbol name
and uses a list of terms as arguments for the atom.
|
DLPNeg(java.lang.String symbol,
java.util.List<Term<?>> terms)
default constructor, create an atom from a functor name
and a list of terms.
|
ListTermValue(java.util.Collection<? extends Term<?>> terms) |
SetTerm(java.util.Collection<Term<?>> terms) |
Modifier and Type | Method and Description |
---|---|
<C extends Term<?>> |
NLPNot.getTerms(java.lang.Class<C> cls) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Term<?>> |
NLPRule.getTerms() |
java.util.Set<Term<?>> |
NLPNot.getTerms() |
Modifier and Type | Method and Description |
---|---|
NLPProgram |
NLPProgram.exchange(Term<?> v,
Term<?> t) |
NLPProgram |
NLPProgram.exchange(Term<?> v,
Term<?> t) |
NLPRule |
NLPRule.substitute(Term<?> v,
Term<?> t) |
NLPRule |
NLPRule.substitute(Term<?> v,
Term<?> t) |
NLPProgram |
NLPProgram.substitute(Term<?> t,
Term<?> v) |
NLPProgram |
NLPProgram.substitute(Term<?> t,
Term<?> v) |
NLPNot |
NLPNot.substitute(Term<?> v,
Term<?> t) |
NLPNot |
NLPNot.substitute(Term<?> v,
Term<?> t) |
Modifier and Type | Method and Description |
---|---|
NLPProgram |
NLPProgram.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |
NLPProgram |
NLPProgram.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map) |