Uses of Interface
net.sf.tweety.logics.commons.syntax.interfaces.Term

Packages that use Term

Package	Description
net.sf.tweety.action.query.syntax
net.sf.tweety.action.signature
net.sf.tweety.arg.delp
net.sf.tweety.arg.delp.parser
net.sf.tweety.arg.delp.syntax
net.sf.tweety.arg.dung.ldo.syntax
net.sf.tweety.logics.commons.syntax
net.sf.tweety.logics.commons.syntax.interfaces
net.sf.tweety.logics.dl.syntax
net.sf.tweety.logics.fol.parser
net.sf.tweety.logics.fol.semantics
net.sf.tweety.logics.fol.syntax
net.sf.tweety.logics.ml.parser
net.sf.tweety.logics.ml.semantics
net.sf.tweety.logics.ml.syntax
net.sf.tweety.logics.mln.reasoner
net.sf.tweety.logics.mln.syntax
net.sf.tweety.logics.pl.syntax
net.sf.tweety.logics.rcl.syntax
net.sf.tweety.logics.rdl.syntax
net.sf.tweety.logics.rpcl.syntax
net.sf.tweety.lp.asp.parser
net.sf.tweety.lp.asp.syntax
net.sf.tweety.lp.nlp.syntax

Uses of Term in net.sf.tweety.action.query.syntax

Method parameters in net.sf.tweety.action.query.syntax with type arguments of type Term

Modifier and Type	Method	Description
QueryProposition	AlwaysQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	AlwaysQuery.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	NecessarilyQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	NecessarilyQuery.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> 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.
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.

Uses of Term in net.sf.tweety.action.signature

Method parameters in net.sf.tweety.action.signature with type arguments of type Term

Modifier and Type	Method	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.

Uses of Term in net.sf.tweety.arg.delp

Fields in net.sf.tweety.arg.delp with type parameters of type Term

Modifier and Type	Field	Description
private static java.util.List<Term<?>>	TestArguments.TINA

Uses of Term in net.sf.tweety.arg.delp.parser

Methods in net.sf.tweety.arg.delp.parser that return Term

Modifier and Type	Method	Description
Term	DelpParser.Term(DefeasibleLogicProgram delp, FolSignature signature)

Uses of Term in net.sf.tweety.arg.delp.syntax

Methods in net.sf.tweety.arg.delp.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	DelpRule.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.arg.delp.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.Set<Term<?>>	DelpRule.getTerms()

Methods in net.sf.tweety.arg.delp.syntax with parameters of type Term

Modifier and Type	Method	Description
RelationalFormula	DefeasibleRule.substitute(Term<?> v, Term<?> t)
RelationalFormula	DelpFact.substitute(Term<?> v, Term<?> t)
abstract RelationalFormula	DelpRule.substitute(Term<?> v, Term<?> t)
RelationalFormula	StrictRule.substitute(Term<?> v, Term<?> t)

Uses of Term in net.sf.tweety.arg.dung.ldo.syntax

Methods in net.sf.tweety.arg.dung.ldo.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<? extends Term<?>>	LdoArgument.getArguments()

Methods in net.sf.tweety.arg.dung.ldo.syntax with parameters of type Term

Modifier and Type	Method	Description
void	LdoArgument.addArgument(Term<?> arg)

Uses of Term in net.sf.tweety.logics.commons.syntax

Classes in net.sf.tweety.logics.commons.syntax that implement Term

Modifier and Type	Class	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 a logic language.

Methods in net.sf.tweety.logics.commons.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	ComplexLogicalFormulaAdapter.containsTermsOfType(java.lang.Class<C> cls)
<C extends Term<?>> boolean	RelationalFormula.containsTermsOfType(java.lang.Class<C> cls)
<C extends Term<?>> boolean	Sort.containsTermsOfType(java.lang.Class<C> cls)
<C extends Term<?>> boolean	TermAdapter.containsTermsOfType(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	AssociativeFormulaSupport.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ComplexLogicalFormulaAdapter.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	FunctionalTerm.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	QuantifiedFormulaSupport.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	Sort.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	TermAdapter.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.logics.commons.syntax that return Term

Modifier and Type	Method	Description
Term<?>	FunctionalTerm.substitute(Term<?> v, Term<?> t)
Term<?>	TermAdapter.substitute(Term<?> v, Term<?> t)

Methods in net.sf.tweety.logics.commons.syntax that return types with arguments of type Term

Modifier and Type	Method	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<?>>	FunctionalTerm.getArguments()
java.util.Set<Term<?>>	AssociativeFormulaSupport.getTerms()
java.util.Set<Term<?>>	FunctionalTerm.getTerms()
java.util.Set<Term<?>>	QuantifiedFormulaSupport.getTerms()
java.util.Set<Term<?>>	Sort.getTerms()
java.util.Set<Term<?>>	TermAdapter.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.

Methods in net.sf.tweety.logics.commons.syntax with parameters of type Term

Modifier and Type	Method	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)
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.
boolean	Sort.remove(Term<?> term)	Removes the given term from this sort.
ComplexLogicalFormula	AssociativeFormulaSupport.substitute(Term<?> v, Term<?> t)
Term<?>	FunctionalTerm.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.
Term<?>	TermAdapter.substitute(Term<?> v, Term<?> t)

Method parameters in net.sf.tweety.logics.commons.syntax with type arguments of type Term

Modifier and Type	Method	Description
java.util.Set<java.util.Map<Variable,Term<?>>>	RelationalFormula.allSubstitutions(java.util.Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
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)
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.

Constructors in net.sf.tweety.logics.commons.syntax with parameters of type Term

Constructor	Description
FunctionalTerm(Functor functor, Term<?>... terms)

Constructor parameters in net.sf.tweety.logics.commons.syntax with type arguments of type Term

Constructor	Description
FunctionalTerm(Functor functor, java.util.List<Term<?>> arguments)	Creates a new functional term with the given functor and the given list of arguments.

Uses of Term in net.sf.tweety.logics.commons.syntax.interfaces

Methods in net.sf.tweety.logics.commons.syntax.interfaces with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	LogicStructure.containsTermsOfType(java.lang.Class<C> cls)	Checks if this logical structure contains at least one term of type C.
<C extends Term<?>> java.util.Set<C>	LogicStructure.getTerms(java.lang.Class<C> cls)	Processes the set containing all terms of type C.

Methods in net.sf.tweety.logics.commons.syntax.interfaces that return Term

Modifier and Type	Method	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.

Methods in net.sf.tweety.logics.commons.syntax.interfaces that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<? extends Term<?>>	Atom.getArguments()
java.util.Set<Term<?>>	LogicStructure.getTerms()

Methods in net.sf.tweety.logics.commons.syntax.interfaces with parameters of type Term

Modifier and Type	Method	Description
void	Atom.addArgument(Term<?> arg)	Adds an argument to the atom's argument list
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.
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.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.
Term<?>	Term.substitute(Term<?> v, Term<?> t)	Substitutes all occurrences of term "v" in this term by term "t" and returns the new term.

Method parameters in net.sf.tweety.logics.commons.syntax.interfaces with type arguments of type Term

Modifier and Type	Method	Description
static Atom.RETURN_SET_PREDICATE	Atom.AtomImpl.implSetPredicate(Predicate old, Predicate newer, java.util.List<Term<?>> arguments)
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.
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.

Uses of Term in net.sf.tweety.logics.dl.syntax

Classes in net.sf.tweety.logics.dl.syntax that implement Term

Modifier and Type	Class	Description
class	Individual	This class models an individual in description logic, also known as an object.

Uses of Term in net.sf.tweety.logics.fol.parser

Methods in net.sf.tweety.logics.fol.parser that return types with arguments of type Term

Modifier and Type	Method	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.
private java.util.List<Term<?>>	TPTPParser.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.

Uses of Term in net.sf.tweety.logics.fol.semantics

Methods in net.sf.tweety.logics.fol.semantics with parameters of type Term

Modifier and Type	Method	Description
HerbrandInterpretation	HerbrandInterpretation.exchange(Term<?> t1, Term<?> t2)	Substitutes every occurrence of "t1" by "t2" and vice versa and returns the new interpretation.

Method parameters in net.sf.tweety.logics.fol.semantics with type arguments of type Term

Modifier and Type	Method	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.

Uses of Term in net.sf.tweety.logics.fol.syntax

Fields in net.sf.tweety.logics.fol.syntax with type parameters of type Term

Modifier and Type	Field	Description
private java.util.List<Term<?>>	FolAtom.arguments	The arguments of the atom

Methods in net.sf.tweety.logics.fol.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	AssociativeFolFormula.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	Equivalence.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ExistsQuantifiedFormula.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	FolAtom.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ForallQuantifiedFormula.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	Implication.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	Negation.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	SpecialFormula.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.logics.fol.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<Term<?>>	FolAtom.getArguments()
java.util.Set<Term<?>>	AssociativeFolFormula.getTerms()
java.util.Set<Term<?>>	Equivalence.getTerms()
java.util.Set<Term<?>>	ExistsQuantifiedFormula.getTerms()
java.util.Set<Term<?>>	FolAtom.getTerms()
java.util.Set<Term<?>>	ForallQuantifiedFormula.getTerms()
java.util.Set<Term<?>>	Implication.getTerms()
java.util.Set<Term<?>>	Negation.getTerms()
java.util.Set<Term<?>>	SpecialFormula.getTerms()

Methods in net.sf.tweety.logics.fol.syntax with parameters of type Term

Modifier and Type	Method	Description
void	FolAtom.addArgument(Term<?> term)	Appends the given argument to this atom's arguments and returns itself.
AssociativeFolFormula	AssociativeFolFormula.substitute(Term<?> v, Term<?> t)
Conjunction	Conjunction.substitute(Term<?> v, Term<?> t)
FolFormula	Equivalence.substitute(Term<?> v, Term<?> t)
ExistsQuantifiedFormula	ExistsQuantifiedFormula.substitute(Term<?> v, Term<?> t)
FolAtom	FolAtom.substitute(Term<?> v, Term<?> t)
abstract FolFormula	FolFormula.substitute(Term<?> v, Term<?> t)
ForallQuantifiedFormula	ForallQuantifiedFormula.substitute(Term<?> v, Term<?> t)
FolFormula	Implication.substitute(Term<?> v, Term<?> t)
Negation	Negation.substitute(Term<?> v, Term<?> t)
FolFormula	SpecialFormula.substitute(Term<?> v, Term<?> t)

Method parameters in net.sf.tweety.logics.fol.syntax with type arguments of type Term

Modifier and Type	Method	Description
AssociativeFolFormula	AssociativeFolFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> termMap)
AssociativeFolFormula	AssociativeFolFormula.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> termMap)

Constructors in net.sf.tweety.logics.fol.syntax with parameters of type Term

Constructor	Description
FolAtom(Predicate predicate, Term<?>... terms)

Constructor parameters in net.sf.tweety.logics.fol.syntax with type arguments of type Term

Constructor	Description
FolAtom(Predicate predicate, java.util.List<? extends Term<?>> arguments)	Creates a new atom with the given predicate and list of terms

Uses of Term in net.sf.tweety.logics.ml.parser

Methods in net.sf.tweety.logics.ml.parser that return types with arguments of type Term

Modifier and Type	Method	Description
private java.util.List<Term<?>>	MlParser.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.

Uses of Term in net.sf.tweety.logics.ml.semantics

Methods in net.sf.tweety.logics.ml.semantics with parameters of type Term

Modifier and Type	Method	Description
MlHerbrandInterpretation	MlHerbrandInterpretation.exchange(Term<?> t1, Term<?> t2)	Substitutes every occurrence of "t1" by "t2" and vice versa and returns the new interpretation.

Method parameters in net.sf.tweety.logics.ml.semantics with type arguments of type Term

Modifier and Type	Method	Description
MlHerbrandInterpretation	MlHerbrandInterpretation.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
MlHerbrandInterpretation	MlHerbrandInterpretation.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

Uses of Term in net.sf.tweety.logics.ml.syntax

Methods in net.sf.tweety.logics.ml.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	MlFormula.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.logics.ml.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.Set<Term<?>>	MlFormula.getTerms()

Methods in net.sf.tweety.logics.ml.syntax with parameters of type Term

Modifier and Type	Method	Description
FolFormula	Necessity.substitute(Term<?> v, Term<?> t)
FolFormula	Possibility.substitute(Term<?> v, Term<?> t)

Uses of Term in net.sf.tweety.logics.mln.reasoner

Methods in net.sf.tweety.logics.mln.reasoner with parameters of type Term

Modifier and Type	Method	Description
private java.lang.String	AlchemyMlnReasoner.alchemyStringForTerm(Term<?> t)	Returns the string in Alchemy syntax representing the given term.

Uses of Term in net.sf.tweety.logics.mln.syntax

Methods in net.sf.tweety.logics.mln.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	MlnFormula.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.logics.mln.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.Set<Term<?>>	MlnFormula.getTerms()

Methods in net.sf.tweety.logics.mln.syntax with parameters of type Term

Modifier and Type	Method	Description
RelationalFormula	MlnFormula.substitute(Term<?> v, Term<?> t)

Uses of Term in net.sf.tweety.logics.pl.syntax

Methods in net.sf.tweety.logics.pl.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<? extends Term<?>>	Proposition.getArguments()

Methods in net.sf.tweety.logics.pl.syntax with parameters of type Term

Modifier and Type	Method	Description
void	Proposition.addArgument(Term<?> arg)

Uses of Term in net.sf.tweety.logics.rcl.syntax

Methods in net.sf.tweety.logics.rcl.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	RelationalConditional.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.logics.rcl.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.Set<Term<?>>	RelationalConditional.getTerms()

Methods in net.sf.tweety.logics.rcl.syntax with parameters of type Term

Modifier and Type	Method	Description
RelationalFormula	RelationalConditional.substitute(Term<?> v, Term<?> t)

Uses of Term in net.sf.tweety.logics.rdl.syntax

Methods in net.sf.tweety.logics.rdl.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	DefaultRule.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.logics.rdl.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.Set<Term<?>>	DefaultRule.getTerms()

Methods in net.sf.tweety.logics.rdl.syntax with parameters of type Term

Modifier and Type	Method	Description
RelationalFormula	DefaultRule.substitute(Term<?> v, Term<?> t)

Uses of Term in net.sf.tweety.logics.rpcl.syntax

Methods in net.sf.tweety.logics.rpcl.syntax with parameters of type Term

Modifier and Type	Method	Description
RpclBeliefSet	RpclBeliefSet.exchange(Term<?> a, Term<?> b)	Exchanges every occurence of "a" by "b" and vice versa.
RelationalFormula	RelationalProbabilisticConditional.substitute(Term<?> v, Term<?> t)

Uses of Term in net.sf.tweety.lp.asp.parser

Methods in net.sf.tweety.lp.asp.parser that return Term

Modifier and Type	Method	Description
Term<?>	InstantiateVisitor.visit(ASTAriTerm node, java.lang.Object data)
Term<?>	InstantiateVisitor.visit(ASTTerm node, java.lang.Object data)

Methods in net.sf.tweety.lp.asp.parser that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<Term<?>>	InstantiateVisitor.visit(ASTTermList node, java.lang.Object data)
java.util.List<Term<?>>	InstantiateVisitor.visit(ASTWeight node, java.lang.Object data)

Uses of Term in net.sf.tweety.lp.asp.syntax

Classes in net.sf.tweety.lp.asp.syntax that implement Term

Modifier and Type	Class	Description
class	ArithmeticTerm	This class represents an arithmetic term in the ASP-Core-2 format.

Fields in net.sf.tweety.lp.asp.syntax declared as Term

Modifier and Type	Field	Description
private Term<?>	ComparativeAtom.left	The left term of the comparative atom.
private Term<?>	AggregateAtom.leftGuard	A term that the aggregate's resulting value will be compared to using the comparative operator.
private Term<?>	ASPRule.level
private Term<?>	ComparativeAtom.right	The right term of the comparative atom.
private Term<?>	AggregateAtom.rightGuard	A term that the aggregate's resulting value will be compared to using the comparative operator.
private Term<?>	ASPRule.weight	Additional attributes that can be used for weak constraints (rules with empty heads).

Fields in net.sf.tweety.lp.asp.syntax with type parameters of type Term

Modifier and Type	Field	Description
protected java.util.List<Term<?>>	ASPAtom.arguments	A list of arguments of the atom
private java.util.List<Term<?>>	ASPRule.constraint_terms
private java.util.List<Term<?>>	AggregateElement.left	The term tuple of the aggregate element.

Methods in net.sf.tweety.lp.asp.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	ASPElement.containsTermsOfType(java.lang.Class<C> cls)
<C extends Term<?>> boolean	ASPHead.containsTermsOfType(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	AggregateAtom.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	AggregateElement.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ASPAtom.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ASPHead.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ASPRule.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	ComparativeAtom.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	DefaultNegation.getTerms(java.lang.Class<C> cls)
<C extends Term<?>> java.util.Set<C>	StrictNegation.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.lp.asp.syntax that return Term

Modifier and Type	Method	Description
Term<?>	ArithmeticTerm.getLeft()	Returns the left subterm of this arithmetic term.
Term<?>	ComparativeAtom.getLeft()	Returns the left (first) term of the comparative atom.
Term<?>	AggregateAtom.getLeftGuard()	Get the left relation term (right guard).
Term<?>	ASPRule.getLevel()
Term<?>	ArithmeticTerm.getRight()	Returns the right subterm of this arithmetic term.
Term<?>	ComparativeAtom.getRight()	Returns the right (second) term of the comparative atom.
Term<?>	AggregateAtom.getRightGuard()	Returns the right relation term (right guard).
Term<?>	ASPAtom.getTerm(int i)
Term<?>	ASPRule.getWeight()

Methods in net.sf.tweety.lp.asp.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<? extends Term<?>>	ASPAtom.getArguments()
java.util.List<? extends Term<?>>	StrictNegation.getArguments()
java.util.List<Term<?>>	ASPRule.getConstraintTerms()
java.util.List<Term<?>>	AggregateElement.getLeft()	Returns the left part of the Aggregate element.
java.util.Set<Term<?>>	AggregateAtom.getTerms()
java.util.Set<Term<?>>	AggregateElement.getTerms()
java.util.Set<Term<?>>	ASPAtom.getTerms()
java.util.Set<Term<?>>	ASPHead.getTerms()
java.util.Set<Term<?>>	ASPRule.getTerms()
java.util.Set<Term<?>>	ComparativeAtom.getTerms()
java.util.Set<Term<?>>	DefaultNegation.getTerms()
java.util.Set<Term<?>>	StrictNegation.getTerms()

Methods in net.sf.tweety.lp.asp.syntax with parameters of type Term

Modifier and Type	Method	Description
void	ASPAtom.addArgument(Term<?> arg)
void	StrictNegation.addArgument(Term<?> arg)
ASPAtom	ASPAtom.cloneWithAddedTerm(Term<?> term)
abstract ASPLiteral	ASPLiteral.cloneWithAddedTerm(Term<?> term)	Creates a copy of the literal and adds the given term as argument to the end of the argument list.
ASPLiteral	StrictNegation.cloneWithAddedTerm(Term<?> term)
AggregateElement	AggregateElement.exchange(Term<?> v, Term<?> t)
ASPElement	ASPElement.exchange(Term<?> v, Term<?> t)
ASPHead	ASPHead.exchange(Term<?> v, Term<?> t)
ASPRule	ASPRule.exchange(Term<?> v, Term<?> t)
Program	Program.exchange(Term<?> v, Term<?> t)
void	AggregateAtom.setLeftGuard(Term<?> relationTerm)	Set the left relation term (right guard).
void	ASPRule.setLevel(Term<?> level)
void	AggregateAtom.setRightGuard(Term<?> relationTerm)	Set the right relation term (right guard).
void	ASPRule.setWeight(Term<?> weight)
AggregateAtom	AggregateAtom.substitute(Term<?> t, Term<?> v)
AggregateElement	AggregateElement.substitute(Term<?> t, Term<?> v)
ASPAtom	ASPAtom.substitute(Term<?> v, Term<?> t)
abstract ASPBodyElement	ASPBodyElement.substitute(Term<?> t, Term<?> v)
abstract ASPElement	ASPElement.substitute(Term<?> t, Term<?> v)
ASPHead	ASPHead.substitute(Term<?> t, Term<?> v)
ASPRule	ASPRule.substitute(Term<?> v, Term<?> t)
ComparativeAtom	ComparativeAtom.substitute(Term<?> t, Term<?> v)
ASPBodyElement	DefaultNegation.substitute(Term<?> t, Term<?> v)
Program	Program.substitute(Term<?> v, Term<?> t)
StrictNegation	StrictNegation.substitute(Term<?> v, Term<?> t)

Method parameters in net.sf.tweety.lp.asp.syntax with type arguments of type Term

Modifier and Type	Method	Description
AggregateElement	AggregateElement.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
AggregateElement	AggregateElement.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
ASPElement	ASPElement.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
ASPElement	ASPElement.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
ASPHead	ASPHead.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
ASPHead	ASPHead.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Program	Program.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
Program	Program.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)

Constructors in net.sf.tweety.lp.asp.syntax with parameters of type Term

Constructor	Description
AggregateAtom(ASPOperator.AggregateFunction func, java.util.List<AggregateElement> elements, ASPOperator.BinaryOperator relation, Term<?> t)	Creates a new Aggregate with the given aggregate function, the given aggregate elements, and the given aggregate relation.
AggregateAtom(ASPOperator.AggregateFunction func, java.util.List<AggregateElement> elements, ASPOperator.BinaryOperator relation, Term<?> t, ASPOperator.BinaryOperator relation2, Term<?> t2)	Creates a new Aggregate with the given aggregate function, the given aggregate elements, and the given left and right aggregate relations.
ArithmeticTerm(ASPOperator.ArithmeticOperator op, Term<?> t)	Creates an arithmetic term of the form -(t)
ArithmeticTerm(ASPOperator.ArithmeticOperator op, Term<?> left, Term<?> right)
ASPAtom(java.lang.String symbol, Term<?>... terms)	Creates an atom with the given predicate as name and the given terms as argument
ASPRule(java.util.List<ASPBodyElement> nafliterals, Term<?> weight, java.util.List<Term<?>> terms)	Creates a constraint with the given weight and terms.
ASPRule(java.util.List<ASPBodyElement> body, Term<?> weight, Term<?> level, java.util.List<Term<?>> terms)	Creates a constraint with the given weight, level and terms.
ComparativeAtom(ASPOperator.BinaryOperator op, Term<?> left, Term<?> right)

Constructor parameters in net.sf.tweety.lp.asp.syntax with type arguments of type Term

Constructor	Description
AggregateElement(java.util.List<Term<?>> l, java.util.List<ASPBodyElement> r)	Creates a new Aggregate Element with the given list of terms and the given list of naf literals.
ArithmeticTerm(Triple<ASPOperator.ArithmeticOperator,Term<?>,Term<?>> triple)
ArithmeticTerm(Triple<ASPOperator.ArithmeticOperator,Term<?>,Term<?>> triple)
ASPAtom(Predicate p, java.util.List<Term<?>> terms)	Creates a new atom with the given predicate and terms.
StrictNegation(Predicate p, java.util.List<Term<?>> terms)	Creates a new negation with the given predicate and terms.

Uses of Term in net.sf.tweety.lp.nlp.syntax

Methods in net.sf.tweety.lp.nlp.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> java.util.Set<C>	NLPNot.getTerms(java.lang.Class<C> cls)

Methods in net.sf.tweety.lp.nlp.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.Set<Term<?>>	NLPNot.getTerms()
java.util.Set<Term<?>>	NLPRule.getTerms()

Methods in net.sf.tweety.lp.nlp.syntax with parameters of type Term

Modifier and Type	Method	Description
NLPProgram	NLPProgram.exchange(Term<?> v, Term<?> t)
NLPNot	NLPNot.substitute(Term<?> v, Term<?> t)
NLPProgram	NLPProgram.substitute(Term<?> t, Term<?> v)
NLPRule	NLPRule.substitute(Term<?> v, Term<?> t)

Method parameters in net.sf.tweety.lp.nlp.syntax with type arguments of type Term

Modifier and Type	Method	Description
NLPProgram	NLPProgram.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)
NLPProgram	NLPProgram.substitute(java.util.Map<? extends Term<?>,? extends Term<?>> map)