Uses of Interface
org.tweetyproject.logics.commons.syntax.interfaces.Term

Packages that use Term

Package	Description
org.tweetyproject.action.query.syntax
org.tweetyproject.action.signature
org.tweetyproject.arg.aba.syntax
org.tweetyproject.arg.aspic.syntax
org.tweetyproject.arg.delp.parser
org.tweetyproject.arg.delp.syntax
org.tweetyproject.arg.dung.ldo.syntax
org.tweetyproject.logics.commons.syntax
org.tweetyproject.logics.commons.syntax.interfaces
org.tweetyproject.logics.dl.syntax
org.tweetyproject.logics.fol.semantics
org.tweetyproject.logics.fol.syntax
org.tweetyproject.logics.ml.semantics
org.tweetyproject.logics.ml.syntax
org.tweetyproject.logics.mln.syntax
org.tweetyproject.logics.pl.syntax
org.tweetyproject.logics.rcl.syntax
org.tweetyproject.logics.rdl.syntax
org.tweetyproject.logics.rpcl.syntax
org.tweetyproject.lp.asp.parser
org.tweetyproject.lp.asp.syntax
org.tweetyproject.lp.nlp.syntax

Uses of Term in org.tweetyproject.action.query.syntax

Method parameters in org.tweetyproject.action.query.syntax with type arguments of type Term

Modifier and Type	Method	Description
QueryProposition	AlwaysQuery.substitute(Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	AlwaysQuery.substitute(Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	HoldsQuery.substitute(Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	HoldsQuery.substitute(Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	NecessarilyQuery.substitute(Map<? extends Term<?>,? extends Term<?>> map)
QueryProposition	NecessarilyQuery.substitute(Map<? extends Term<?>,? extends Term<?>> map)
abstract QueryProposition	QueryProposition.substitute(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(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 org.tweetyproject.action.signature

Method parameters in org.tweetyproject.action.signature with type arguments of type Term

Modifier and Type	Method	Description
FolAction	FolAction.substitute(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(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 org.tweetyproject.arg.aba.syntax

Methods in org.tweetyproject.arg.aba.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	AbaElement.containsTermsOfType(Class<C> cls)
<C extends Term<?>> Set<C>	Assumption.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	InferenceRule.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	Negation.getTerms(Class<C> cls)

Methods in org.tweetyproject.arg.aba.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
Set<Map<Variable,Term<?>>>	AbaElement.allSubstitutions(Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
Set<Term<?>>	Assumption.getTerms()
Set<Term<?>>	InferenceRule.getTerms()
Set<Term<?>>	Negation.getTerms()

Methods in org.tweetyproject.arg.aba.syntax with parameters of type Term

Modifier and Type	Method	Description
AbaElement<T>	AbaElement.exchange(Term<?> v, Term<?> t)
abstract AbaElement<T>	AbaElement.substitute(Term<?> v, Term<?> t)
Assumption<T>	Assumption.substitute(Term<?> v, Term<?> t)
AbaElement<T>	InferenceRule.substitute(Term<?> v, Term<?> t)
Negation<T>	Negation.substitute(Term<?> v, Term<?> t)

Method parameters in org.tweetyproject.arg.aba.syntax with type arguments of type Term

Modifier and Type	Method	Description
Set<Map<Variable,Term<?>>>	AbaElement.allSubstitutions(Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
AbaElement<T>	AbaElement.substitute(Map<? extends Term<?>,? extends Term<?>> map)
AbaElement<T>	AbaElement.substitute(Map<? extends Term<?>,? extends Term<?>> map)

Uses of Term in org.tweetyproject.arg.aspic.syntax

Methods in org.tweetyproject.arg.aspic.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	InferenceRule.containsTermsOfType(Class<C> cls)
<C extends Term<?>> Set<C>	InferenceRule.getTerms(Class<C> cls)

Methods in org.tweetyproject.arg.aspic.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
Set<Map<Variable,Term<?>>>	InferenceRule.allSubstitutions(Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
Set<Term<?>>	InferenceRule.getTerms()

Methods in org.tweetyproject.arg.aspic.syntax with parameters of type Term

Modifier and Type	Method	Description
InferenceRule<T>	InferenceRule.exchange(Term<?> v, Term<?> t)
DefeasibleInferenceRule<T>	DefeasibleInferenceRule.substitute(Term<?> v, Term<?> t)
abstract InferenceRule<T>	InferenceRule.substitute(Term<?> v, Term<?> t)
StrictInferenceRule<T>	StrictInferenceRule.substitute(Term<?> v, Term<?> t)

Method parameters in org.tweetyproject.arg.aspic.syntax with type arguments of type Term

Modifier and Type	Method	Description
Set<Map<Variable,Term<?>>>	InferenceRule.allSubstitutions(Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
InferenceRule<T>	InferenceRule.substitute(Map<? extends Term<?>,? extends Term<?>> map)
InferenceRule<T>	InferenceRule.substitute(Map<? extends Term<?>,? extends Term<?>> map)

Uses of Term in org.tweetyproject.arg.delp.parser

Methods in org.tweetyproject.arg.delp.parser that return Term

Modifier and Type	Method	Description
final Term	DelpParser.Term(DefeasibleLogicProgram delp, FolSignature signature)	Parses a term (either a variable or a constant) from the input.

Uses of Term in org.tweetyproject.arg.delp.syntax

Methods in org.tweetyproject.arg.delp.syntax with type parameters of type Term

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

Methods in org.tweetyproject.arg.delp.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.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 org.tweetyproject.arg.dung.ldo.syntax

Methods in org.tweetyproject.arg.dung.ldo.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.arg.dung.ldo.syntax with parameters of type Term

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

Uses of Term in org.tweetyproject.logics.commons.syntax

Classes in org.tweetyproject.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 org.tweetyproject.logics.commons.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	ComplexLogicalFormulaAdapter.containsTermsOfType(Class<C> cls)
<C extends Term<?>> boolean	RelationalFormula.containsTermsOfType(Class<C> cls)
<C extends Term<?>> boolean	Sort.containsTermsOfType(Class<C> cls)
<C extends Term<?>> boolean	TermAdapter.containsTermsOfType(Class<C> cls)
<C extends Term<?>> Set<C>	AssociativeFormulaSupport.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ComplexLogicalFormulaAdapter.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	FunctionalTerm.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	QuantifiedFormulaSupport.getTerms(Class<C> cls)	Returns the set of terms of a specified type used in the inner formula.
<C extends Term<?>> Set<C>	Sort.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	TermAdapter.getTerms(Class<C> cls)

Methods in org.tweetyproject.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 org.tweetyproject.logics.commons.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
Set<Map<Variable,Term<?>>>	RelationalFormula.allSubstitutions(Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
List<Term<?>>	FunctionalTerm.getArguments()	Returns an unmodifiable view of the list of arguments for this FunctionalTerm.
Set<Term<?>>	AssociativeFormulaSupport.getTerms()
Set<Term<?>>	FunctionalTerm.getTerms()
Set<Term<?>>	QuantifiedFormulaSupport.getTerms()	Returns the set of terms used in the inner formula.
Set<Term<?>>	Sort.getTerms()
Set<Term<?>>	TermAdapter.getTerms()
static Map<Sort,Set<Term<?>>>	Sort.sortTerms(Collection<? extends Term<?>> terms)	Sorts the set of given terms by their sorts, i.e.

Methods in org.tweetyproject.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 org.tweetyproject.logics.commons.syntax with type arguments of type Term

Modifier and Type	Method	Description
Set<Map<Variable,Term<?>>>	RelationalFormula.allSubstitutions(Collection<? extends Term<?>> terms)	Computes all possible substitutions, i.e.
static Map<Sort,Set<Term<?>>>	Sort.sortTerms(Collection<? extends Term<?>> terms)	Sorts the set of given terms by their sorts, i.e.
ComplexLogicalFormula	ComplexLogicalFormulaAdapter.substitute(Map<? extends Term<?>,? extends Term<?>> map)
ComplexLogicalFormula	ComplexLogicalFormulaAdapter.substitute(Map<? extends Term<?>,? extends Term<?>> map)
RelationalFormula	RelationalFormula.substitute(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(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 org.tweetyproject.logics.commons.syntax with parameters of type Term

Modifier	Constructor	Description
	FunctionalTerm(Functor functor, Term<?>... terms)	Constructs a new FunctionalTerm with the specified functor and arguments.

Constructor parameters in org.tweetyproject.logics.commons.syntax with type arguments of type Term

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

Uses of Term in org.tweetyproject.logics.commons.syntax.interfaces

Methods in org.tweetyproject.logics.commons.syntax.interfaces with type parameters of type Term

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

Methods in org.tweetyproject.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 org.tweetyproject.logics.commons.syntax.interfaces that return types with arguments of type Term

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

Methods in org.tweetyproject.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 org.tweetyproject.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, List<Term<?>> arguments)	Return set predicate
ComplexLogicalFormula	ComplexLogicalFormula.substitute(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(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(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(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 org.tweetyproject.logics.dl.syntax

Classes in org.tweetyproject.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 org.tweetyproject.logics.fol.semantics

Methods in org.tweetyproject.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 org.tweetyproject.logics.fol.semantics with type arguments of type Term

Modifier and Type	Method	Description
HerbrandInterpretation	HerbrandInterpretation.exchange(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(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 org.tweetyproject.logics.fol.syntax

Methods in org.tweetyproject.logics.fol.syntax with type parameters of type Term

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

Methods in org.tweetyproject.logics.fol.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.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 org.tweetyproject.logics.fol.syntax with type arguments of type Term

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

Constructors in org.tweetyproject.logics.fol.syntax with parameters of type Term

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

Constructor parameters in org.tweetyproject.logics.fol.syntax with type arguments of type Term

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

Uses of Term in org.tweetyproject.logics.ml.semantics

Methods in org.tweetyproject.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 org.tweetyproject.logics.ml.semantics with type arguments of type Term

Modifier and Type	Method	Description
MlHerbrandInterpretation	MlHerbrandInterpretation.exchange(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(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 org.tweetyproject.logics.ml.syntax

Methods in org.tweetyproject.logics.ml.syntax with type parameters of type Term

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

Methods in org.tweetyproject.logics.ml.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.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 org.tweetyproject.logics.mln.syntax

Methods in org.tweetyproject.logics.mln.syntax with type parameters of type Term

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

Methods in org.tweetyproject.logics.mln.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.logics.mln.syntax with parameters of type Term

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

Uses of Term in org.tweetyproject.logics.pl.syntax

Methods in org.tweetyproject.logics.pl.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.logics.pl.syntax with parameters of type Term

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

Uses of Term in org.tweetyproject.logics.rcl.syntax

Methods in org.tweetyproject.logics.rcl.syntax with type parameters of type Term

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

Methods in org.tweetyproject.logics.rcl.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.logics.rcl.syntax with parameters of type Term

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

Uses of Term in org.tweetyproject.logics.rdl.syntax

Methods in org.tweetyproject.logics.rdl.syntax with type parameters of type Term

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

Methods in org.tweetyproject.logics.rdl.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.logics.rdl.syntax with parameters of type Term

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

Uses of Term in org.tweetyproject.logics.rpcl.syntax

Methods in org.tweetyproject.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 org.tweetyproject.lp.asp.parser

Methods in org.tweetyproject.lp.asp.parser that return Term

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

Methods in org.tweetyproject.lp.asp.parser that return types with arguments of type Term

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

Uses of Term in org.tweetyproject.lp.asp.syntax

Classes in org.tweetyproject.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.

Methods in org.tweetyproject.lp.asp.syntax with type parameters of type Term

Modifier and Type	Method	Description
<C extends Term<?>> boolean	ASPElement.containsTermsOfType(Class<C> cls)
<C extends Term<?>> boolean	ClassicalHead.containsTermsOfType(Class<C> cls)
<C extends Term<?>> Set<C>	AggregateAtom.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	AggregateElement.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	AggregateHead.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ASPAtom.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ASPRule.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ChoiceElement.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ChoiceHead.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ClassicalHead.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	ComparativeAtom.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	DefaultNegation.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	OptimizationElement.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	OptimizationStatement.getTerms(Class<C> cls)
<C extends Term<?>> Set<C>	StrictNegation.getTerms(Class<C> cls)

Methods in org.tweetyproject.lp.asp.syntax that return Term

Modifier and Type	Method	Description
Term<?>	ArithmeticTerm.getLeft()	Return the left subterm of this arithmetic term.
Term<?>	ComparativeAtom.getLeft()
Term<?>	AggregateAtom.getLeftGuard()	Get the left relation term (left guard).
Term<?>	ChoiceHead.getLeftGuard()	Return the left guard (comparison term)
Term<?>	ASPRule.getLevel()	Return the level attribute of this constraint.
Term<?>	OptimizationElement.getLevel()	Return level (priority) of this optimization element.
Term<?>	ArithmeticTerm.getRight()	Return the right subterm of this arithmetic term.
Term<?>	ComparativeAtom.getRight()
Term<?>	AggregateAtom.getRightGuard()	Return the right relation term (right guard).
Term<?>	ChoiceHead.getRightGuard()	Return the right guard (comparison term)
Term<?>	ASPAtom.getTerm(int i)	Retrieves the term at the specified index from the list of arguments.
Term<?>	ASPRule.getWeight()	Return the weight of this constraint.
Term<?>	OptimizationElement.getWeight()	Return the weight of this optimization element.

Methods in org.tweetyproject.lp.asp.syntax that return types with arguments of type Term

Modifier and Type	Method	Description
List<? extends Term<?>>	ASPAtom.getArguments()
List<? extends Term<?>>	StrictNegation.getArguments()
List<Term<?>>	ASPRule.getConstraintTerms()	Return the constraint terms of this rule.
List<Term<?>>	AggregateElement.getLeft()	Return the left part (the term tuple) of the Aggregate element.
List<Term<?>>	OptimizationElement.getOptTerms()	Return the term tuple of this optimization element.
Set<Term<?>>	AggregateAtom.getTerms()
Set<Term<?>>	AggregateElement.getTerms()
Set<Term<?>>	AggregateHead.getTerms()
Set<Term<?>>	ASPAtom.getTerms()
Set<Term<?>>	ASPRule.getTerms()
Set<Term<?>>	ChoiceElement.getTerms()
Set<Term<?>>	ChoiceHead.getTerms()
Set<Term<?>>	ClassicalHead.getTerms()
Set<Term<?>>	ComparativeAtom.getTerms()
Set<Term<?>>	DefaultNegation.getTerms()
Set<Term<?>>	OptimizationElement.getTerms()
Set<Term<?>>	OptimizationStatement.getTerms()
Set<Term<?>>	StrictNegation.getTerms()

Methods in org.tweetyproject.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)
ASPRule	ASPRule.exchange(Term<?> v, Term<?> t)
ClassicalHead	ClassicalHead.exchange(Term<?> v, Term<?> t)
Program	Program.exchange(Term<?> v, Term<?> t)
void	AggregateAtom.setLeft(Term<?> term, ASPOperator.BinaryOperator op)	Set the left relation term and operator.
void	AggregateAtom.setLeftGuard(Term<?> relationTerm)	Set the left relation term (left guard).
void	ChoiceHead.setLeftGuard(Term<?> leftTerm)	Set the left guard (comparison term)
void	ASPRule.setLevel(Term<?> level)	Set the level attribute of this constraint.
void	OptimizationElement.setLevel(Term<?> l)	Sets the level (priority) of this optimization statement.
void	AggregateAtom.setRight(Term<?> term, ASPOperator.BinaryOperator op)	Set the right relation term and operator.
void	AggregateAtom.setRightGuard(Term<?> relationTerm)	Set the right relation term (right guard).
void	ChoiceHead.setRightGuard(Term<?> rightTerm)	Set the right guard (comparison term)
void	ASPRule.setWeight(Term<?> weight)	Set the weight attribute of this constraint.
void	OptimizationElement.setWeight(Term<?> w)	Sets the weight of this optimization statement.
AggregateAtom	AggregateAtom.substitute(Term<?> t, Term<?> v)
AggregateElement	AggregateElement.substitute(Term<?> t, Term<?> v)
ASPElement	AggregateHead.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)
ASPRule	ASPRule.substitute(Term<?> v, Term<?> t)
ChoiceElement	ChoiceElement.substitute(Term<?> t, Term<?> v)
ASPElement	ChoiceHead.substitute(Term<?> t, Term<?> v)
ClassicalHead	ClassicalHead.substitute(Term<?> t, Term<?> v)
ComparativeAtom	ComparativeAtom.substitute(Term<?> t, Term<?> v)
ASPBodyElement	DefaultNegation.substitute(Term<?> t, Term<?> v)
OptimizationElement	OptimizationElement.substitute(Term<?> t, Term<?> v)
OptimizationStatement	OptimizationStatement.substitute(Term<?> t, Term<?> v)
Program	Program.substitute(Term<?> v, Term<?> t)
StrictNegation	StrictNegation.substitute(Term<?> v, Term<?> t)

Method parameters in org.tweetyproject.lp.asp.syntax with type arguments of type Term

Modifier and Type	Method	Description
void	ASPRule.setConstraintTerms(List<Term<?>> constraintTerms)	Setter
void	AggregateElement.setLeft(List<Term<?>> terms)	Sets the term tuple of the aggregate element.
void	OptimizationElement.setOptTerms(List<Term<?>> terms)	Sets the term tuple of this optimization element.
AggregateElement	AggregateElement.substitute(Map<? extends Term<?>,? extends Term<?>> map)
AggregateElement	AggregateElement.substitute(Map<? extends Term<?>,? extends Term<?>> map)
ASPElement	ASPElement.substitute(Map<? extends Term<?>,? extends Term<?>> map)
ASPElement	ASPElement.substitute(Map<? extends Term<?>,? extends Term<?>> map)
ClassicalHead	ClassicalHead.substitute(Map<? extends Term<?>,? extends Term<?>> map)
ClassicalHead	ClassicalHead.substitute(Map<? extends Term<?>,? extends Term<?>> map)
Program	Program.substitute(Map<? extends Term<?>,? extends Term<?>> map)
Program	Program.substitute(Map<? extends Term<?>,? extends Term<?>> map)

Constructors in org.tweetyproject.lp.asp.syntax with parameters of type Term

Modifier	Constructor	Description
	AggregateAtom(ASPOperator.AggregateFunction function, List<AggregateElement> elements, ASPOperator.BinaryOperator rightRelation, Term<?> rightBound)	Creates a new Aggregate of the form "#func { elements } op rightBound" with the given aggregate function #func, the given aggregate elements, the given aggregate relation op and the given rightBound.
	AggregateAtom(ASPOperator.AggregateFunction function, List<AggregateElement> elements, ASPOperator.BinaryOperator leftRelation, Term<?> leftBound, ASPOperator.BinaryOperator rightRelation, Term<?> rightBound)	Creates a new Aggregate of the form "leftBound leftOp #func { elements } rightOp rightBound" with the given aggregate function, the given aggregate elements, and the given left and right aggregate relations and bounds.
	AggregateElement(Term<?> term, List<ASPBodyElement> literals)	Creates a new Aggregate Element with the given single term and the given list of naf literals.
	AggregateElement(Term<?> term, ASPBodyElement literal)	Creates a new Aggregate Element with the given single term and the given single literal.
	AggregateElement(Term<?> term, ASPBodyElement... literals)	Creates a new Aggregate Element with the given single term and the given naf literals.
	ArithmeticTerm(Term<?> t)	Creates an arithmetic term of the form '-(t)'
	ArithmeticTerm(ASPOperator.ArithmeticOperator op, Term<?> t)	Creates an arithmetic term of the form '-(t)'
	ArithmeticTerm(ASPOperator.ArithmeticOperator op, Term<?> left, Term<?> right)	Create a new arithmetic term with the given operator and left and right term.
	ASPAtom(String symbol, Term<?>... terms)	Creates an atom with the given predicate as name and the given terms as argument
	ASPAtom(Predicate p, Term<?>... terms)	Creates a new atom with the given predicate and terms.
	ASPRule(List<ASPBodyElement> nafliterals, Term<?> weight, List<Term<?>> terms)	Creates a weak constraint with the given weight and terms.
	ASPRule(List<ASPBodyElement> body, Term<?> weight, Term<?> level, List<Term<?>> terms)	Creates a weak constraint with the given weight, level (priority) and terms.
	ChoiceHead(List<ChoiceElement> elements, ASPOperator.BinaryOperator rightOp, Term<?> rightTerm)
	ChoiceHead(List<ChoiceElement> elements, ASPOperator.BinaryOperator leftOp, Term<?> leftTerm, ASPOperator.BinaryOperator rightOp, Term<?> rightTerm)
	ChoiceHead(ChoiceElement e, ASPOperator.BinaryOperator rightOp, Term<?> rightTerm)
	ComparativeAtom(ASPOperator.BinaryOperator op, Term<?> left, Term<?> right)	Create a new comparative atom with the given operator and left and right term.
	OptimizationElement(Term<?> weight, int priority, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new optimization element with the given weight, priority, terms and literals.
	OptimizationElement(Term<?> weight, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new optimization element with the given weight, terms and literals.
	OptimizationElement(Term<?> weight, Term<?> priority, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new optimization element with the given weight, priority, terms and literals.
	OptimizationElement(Term<?> weight, Term<?> term, ASPBodyElement literal)	Creates a new optimization element with the given single weight, term and literal.
	OptimizationElement(Term<?> term, ASPBodyElement literal)	Creates a new optimization element with the given single term and literal.
	OptimizationStatement(ASPOperator.OptimizeFunction function, Term<?> weight, int priority, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new OptimizatonStatement with the given function, weight, priority and single term-literal tuple.
	OptimizationStatement(ASPOperator.OptimizeFunction function, Term<?> weight, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new OptimizatonStatement with the given function, weight and single term-literal tuple.

Constructor parameters in org.tweetyproject.lp.asp.syntax with type arguments of type Term

Modifier	Constructor	Description
	AggregateElement(List<Term<?>> terms, List<ASPBodyElement> literals)	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)	Create a new arithmetic term based on the given triple of an arithmetic operator and two terms.
	ArithmeticTerm(Triple<ASPOperator.ArithmeticOperator,Term<?>,Term<?>> triple)	Create a new arithmetic term based on the given triple of an arithmetic operator and two terms.
	ASPAtom(Predicate p, List<Term<?>> terms)	Creates a new atom with the given predicate and terms.
	OptimizationElement(Term<?> weight, int priority, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new optimization element with the given weight, priority, terms and literals.
	OptimizationElement(Term<?> weight, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new optimization element with the given weight, terms and literals.
	OptimizationElement(Term<?> weight, Term<?> priority, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new optimization element with the given weight, priority, terms and literals.
	OptimizationStatement(ASPOperator.OptimizeFunction function, Term<?> weight, int priority, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new OptimizatonStatement with the given function, weight, priority and single term-literal tuple.
	OptimizationStatement(ASPOperator.OptimizeFunction function, Term<?> weight, List<Term<?>> terms, List<ASPBodyElement> literals)	Creates a new OptimizatonStatement with the given function, weight and single term-literal tuple.
	StrictNegation(Predicate p, List<Term<?>> terms)	Creates a new negation with the given predicate and terms.

Uses of Term in org.tweetyproject.lp.nlp.syntax

Methods in org.tweetyproject.lp.nlp.syntax with type parameters of type Term

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

Methods in org.tweetyproject.lp.nlp.syntax that return types with arguments of type Term

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

Methods in org.tweetyproject.lp.nlp.syntax with parameters of type Term

Modifier and Type	Method	Description
NLPProgram	NLPProgram.exchange(Term<?> v, Term<?> t)	Exchanges two terms in all rules of the nested logic program.
NLPNot	NLPNot.substitute(Term<?> v, Term<?> t)
NLPProgram	NLPProgram.substitute(Term<?> t, Term<?> v)	Substitutes a term in all rules of the nested logic program.
NLPRule	NLPRule.substitute(Term<?> v, Term<?> t)

Method parameters in org.tweetyproject.lp.nlp.syntax with type arguments of type Term

Modifier and Type	Method	Description
NLPProgram	NLPProgram.substitute(Map<? extends Term<?>,? extends Term<?>> map)	Substitutes multiple terms in all rules of the nested logic program according to the provided map.
NLPProgram	NLPProgram.substitute(Map<? extends Term<?>,? extends Term<?>> map)	Substitutes multiple terms in all rules of the nested logic program according to the provided map.