Uses of Class org.tweetyproject.arg.bipolar.syntax.BArgument

Packages that use BArgument
Package Description

org.tweetyproject.arg.bipolar.syntax

Packages that use BArgument
Package	Description
org.tweetyproject.arg.bipolar.syntax

Uses of BArgument in org.tweetyproject.arg.bipolar.syntax

Methods in org.tweetyproject.arg.bipolar.syntax that return BArgument
Modifier and Type	Method	Description
`BArgument`	BinaryAttack.`getAttacked()`	returns the attacked argument of this attack relation.
`BArgument`	SetAttack.`getAttacked()`	returns the attacked argument of this attack relation.
`BArgument`	BinaryAttack.`getAttacker()`	returns the attacking argument of this attack relation.
`BArgument`	EvidentialArgumentationFramework.`getEta()`	returns the special argument eta
`BArgument`	BinarySupport.`getSupported()`	returns the supported argument of this support relation.
`BArgument`	SetSupport.`getSupported()`	returns the supported argument of this support relation.
`BArgument`	BinarySupport.`getSupporter()`	returns the supporting argument of this support relation.

Methods in org.tweetyproject.arg.bipolar.syntax that return types with arguments of type BArgument
Modifier and Type	Method	Description
`java.util.Set<BArgument>`	AbstractBipolarFramework.`getAttacked(BipolarEntity arg)`	Computes the set {A \| (argument,A) in attacks}.
`java.util.Collection<BArgument>`	AbstractBipolarFramework.`getChildren(Node node)`
`Graph<BArgument>`	AbstractBipolarFramework.`getComplementGraph(int i)`
`java.util.Set<BArgument>`	NecessityArgumentationFramework.`getDeactivatedArguments(java.util.Collection<BArgument> argumentSet)`	computes the set of deactivated arguments of argumentSet a set of arguments S deactivates an argument a iff either S attacks a or S does not support a
`java.util.Set<BArgument>`	AbstractBipolarFramework.`getDirectSupported(BipolarEntity arg)`	Computes the set {A \| (argument,A) in supports}.
`Edge<BArgument>`	AbstractBipolarFramework.`getEdge(BArgument a, BArgument b)`
`java.util.Collection<? extends Edge<? extends BArgument>>`	AbstractBipolarFramework.`getEdges()`
`java.util.Set<BArgument>`	EvidentialArgumentationFramework.`getEvidenceSupportedArguments()`	returns all arguments that have evidential support in this framework
`java.util.Collection<java.util.Collection<BArgument>>`	EvidentialArgumentationFramework.`getMinimalEvidenceSupportedAttackers(BArgument argument)`	computes all subsets which carry out a minimal evidence supported attack on argument
`java.util.Set<java.util.Set<BArgument>>`	EvidentialArgumentationFramework.`getMinimalEvidentialSupporters(BArgument argument)`	computes all subsets which minimal e-support argument
`java.util.Collection<BArgument>`	AbstractBipolarFramework.`getNeighbors(BArgument node)`
`java.util.Collection<BArgument>`	AbstractBipolarFramework.`getNodes()`
`java.util.Collection<BArgument>`	AbstractBipolarFramework.`getParents(Node node)`
`Graph<BArgument>`	AbstractBipolarFramework.`getRestriction(java.util.Collection<BArgument> collection)`
`java.util.Collection<java.util.Collection<BArgument>>`	AbstractBipolarFramework.`getStronglyConnectedComponents()`
`java.util.Collection<Graph<BArgument>>`	AbstractBipolarFramework.`getSubgraphs()`
`java.util.Set<BArgument>`	DeductiveArgumentationFramework.`getSupported(java.util.Collection<BArgument> ext)`	Computes the set {A \| there is a sequence of direct supports from an element of `ext` to A
`java.util.Set<BArgument>`	DeductiveArgumentationFramework.`getSupported(BArgument argument)`	Computes the set {A \| there is a sequence of direct supports from argument to A
`java.util.Set<BArgument>`	EvidentialArgumentationFramework.`getSupported(ArgumentSet argumentSet)`	Computes the set {A \| there is a sequence of direct supports from argumentSet to A}
`java.util.Set<BArgument>`	DeductiveArgumentationFramework.`getSupporters(BArgument argument)`	Computes the set {A \| there is a sequence of direct supports from A to argument
`java.util.Iterator<BArgument>`	ArgumentSet.`iterator()`

Methods in org.tweetyproject.arg.bipolar.syntax with parameters of type BArgument
Modifier and Type	Method	Description
`boolean`	AbstractBipolarFramework.`add(BArgument argument)`	Adds argument to this argumentation framework
`boolean`	ArgumentSet.`add(BArgument arg0)`
`boolean`	DeductiveArgumentationFramework.`addAttack(BArgument attacker, BArgument attacked)`	Adds an attack from the first argument to the second to this deductive argumentation system.
`boolean`	EvidentialArgumentationFramework.`addAttack(ArgumentSet attacker, BArgument attacked)`	Adds an attack from the set of arguments to the argument to this evidential argumentation system.
`boolean`	EvidentialArgumentationFramework.`addAttack(BArgument attacker, BArgument attacked)`	Adds an attack from the first argument to the second to this evidential argumentation system.
`boolean`	NecessityArgumentationFramework.`addAttack(BArgument attacker, BArgument attacked)`	Adds an attack from the first argument to the second to this necessity argumentation system.
`boolean`	EvidentialArgumentationFramework.`addPrimaFacie(BArgument argument)`	Adds a argument with evidential support to this evidential argumentation system If the argument is already in this evidential argumentation system, adds evidential support
`boolean`	DeductiveArgumentationFramework.`addSupport(BArgument supporter, BArgument supported)`	Adds a support from the first argument to the second to this bipolar argumentation framework.
`boolean`	EvidentialArgumentationFramework.`addSupport(ArgumentSet supporter, BArgument supported)`	Adds a support from a set of arguments to an argument to this argumentation framework.
`boolean`	EvidentialArgumentationFramework.`addSupport(BArgument supporter, BArgument supported)`	Adds a support from the first argument to the second to this argumentation framework.
`boolean`	NecessityArgumentationFramework.`addSupport(ArgumentSet supporter, BArgument supported)`	Adds a support from a set of arguments to an argument to this argumentation framework.
`boolean`	NecessityArgumentationFramework.`addSupport(BArgument supporter, BArgument supported)`	Adds a support from the first argument to the second to this argumentation framework.
`boolean`	AbstractBipolarFramework.`areAdjacent(BArgument a, BArgument b)`
`boolean`	SetSupport.`contains(BArgument argument)`	Return true if the given argument is in this support relation.
`boolean`	AbstractBipolarFramework.`existsDirectedPath(BArgument node1, BArgument node2)`
`java.util.Set<BipolarEntity>`	AbstractBipolarFramework.`getAttackers(BArgument argument)`	Computes the set {A \| (A,argument) in attacks}.
`java.util.Set<BipolarEntity>`	EvidentialArgumentationFramework.`getAttackingSets(BArgument argument)`	Computes the set {S \| (S, argument) in attacks}.
`java.util.Set<BipolarEntity>`	AbstractBipolarFramework.`getDirectSupporters(BArgument argument)`	Computes the set {A \| (A,argument) in supports}.
`Edge<BArgument>`	AbstractBipolarFramework.`getEdge(BArgument a, BArgument b)`
`java.util.Set<BinaryAttack>`	DeductiveArgumentationFramework.`getMediatedAttacks(BArgument arg1)`	Calculates the set of mediated attack from "arg1" to other arguments "y", i.e.
`java.util.Collection<java.util.Collection<BArgument>>`	EvidentialArgumentationFramework.`getMinimalEvidenceSupportedAttackers(BArgument argument)`	computes all subsets which carry out a minimal evidence supported attack on argument
`java.util.Set<java.util.Set<BArgument>>`	EvidentialArgumentationFramework.`getMinimalEvidentialSupporters(BArgument argument)`	computes all subsets which minimal e-support argument
`java.util.Collection<BArgument>`	AbstractBipolarFramework.`getNeighbors(BArgument node)`
`java.util.Set<BArgument>`	DeductiveArgumentationFramework.`getSupported(BArgument argument)`	Computes the set {A \| there is a sequence of direct supports from argument to A
`java.util.Set<BinaryAttack>`	DeductiveArgumentationFramework.`getSupportedAttacks(BArgument arg1)`	Calculates the set of supported attack from "arg1" to other arguments "y", i.e.
`java.util.Set<BArgument>`	DeductiveArgumentationFramework.`getSupporters(BArgument argument)`	Computes the set {A \| there is a sequence of direct supports from A to argument
`boolean`	EvidentialArgumentationFramework.`hasEvidentialSupport(BArgument argument, java.util.Collection<BArgument> ext)`	returns true if argument has evidential support from set `ext`.
`boolean`	EvidentialArgumentationFramework.`hasMinimalEvidentialSupport(BArgument argument, java.util.Collection<BArgument> ext)`	returns true if argument has minimal evidential support from set `ext`.
`abstract boolean`	AbstractBipolarFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`	checks whether argument is acceptable wrt.
`boolean`	DeductiveArgumentationFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`
`boolean`	EvidentialArgumentationFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`	return true if argument is acceptable with respect to `ext` argument is acceptable wrt.
`boolean`	NecessityArgumentationFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`	checks whether ext defends argument a set of arguments S defends an argument a iff S u {a} is coherent and S attacks each coherent set T, which attacks a
`boolean`	DeductiveArgumentationFramework.`isAttacked(BArgument argument, java.util.Set<BArgument> argumentSet)`	returns true if some argument of argumentSet attacks argument.
`boolean`	AbstractBipolarFramework.`isAttackedBy(BArgument arg1, BipolarEntity arg2)`	Checks whether arg1 is attacked by arg2.
`boolean`	NecessityArgumentationFramework.`isAttackedBy(BArgument argument, java.util.Collection<BArgument> argumentSet)`	checks whether argument is attacked by any argument in argumentSet
`boolean`	DeductiveArgumentationFramework.`isAttacking(BArgument argument, java.util.Set<BArgument> argSet)`	returns true if some argument of argSet is attacked by argument.
`boolean`	AbstractBipolarFramework.`isDirectSupportedBy(BArgument arg1, BipolarEntity arg2)`	Checks whether arg1 is directly supported by arg2.
`boolean`	EvidentialArgumentationFramework.`isEvidenceSupportedAttack(java.util.Collection<BArgument> ext, BArgument argument)`	returns true if `ext` carries out an evidence supported attack on argument ext e-support-attacks an argument a iff a subset S of ext attacks a and all elements of S have e-support from ext.
`boolean`	DeductiveArgumentationFramework.`isMediatedAttack(BArgument arg1, BArgument arg2)`	Checks whether there exists a mediated attack from "arg1" to "arg2", i.e.
`boolean`	EvidentialArgumentationFramework.`isMinimalEvidenceSupportedAttack(java.util.Collection<BArgument> ext, BArgument argument)`	returns true if `ext` carries out a minimal evidence supported attack on argument i.e.
`boolean`	NecessityArgumentationFramework.`isNCycleFreeIn(BArgument argument, java.util.Collection<BArgument> argumentSet)`	checks if argument is N-Cycle-Free in the set of arguments
`boolean`	DeductiveArgumentationFramework.`isSuperMediatedAttack(BArgument arg1, BArgument arg2)`	Checks whether there exists a super-mediated attack from "arg1" to "arg2", i.e.
`boolean`	DeductiveArgumentationFramework.`isSupportedAttack(BArgument arg1, BArgument arg2)`	Checks whether there exists a supported attack from "arg1" to "arg2", i.e.
`boolean`	AbstractBipolarFramework.`remove(BArgument a)`	Removes the argument and all its attacks and supports
`boolean`	EvidentialArgumentationFramework.`removePrimaFacie(BArgument argument)`	removes evidential support from argument, does not remove argument itself

Method parameters in org.tweetyproject.arg.bipolar.syntax with type arguments of type BArgument
Modifier and Type	Method	Description
`boolean`	AbstractBipolarFramework.`add(Edge<BArgument> edge)`
`boolean`	ArgumentSet.`addAll(java.util.Collection<? extends BArgument> arg0)`
`java.util.Set<BArgument>`	NecessityArgumentationFramework.`getDeactivatedArguments(java.util.Collection<BArgument> argumentSet)`	computes the set of deactivated arguments of argumentSet a set of arguments S deactivates an argument a iff either S attacks a or S does not support a
`Graph<BArgument>`	AbstractBipolarFramework.`getRestriction(java.util.Collection<BArgument> collection)`
`java.util.Set<BArgument>`	DeductiveArgumentationFramework.`getSupported(java.util.Collection<BArgument> ext)`	Computes the set {A \| there is a sequence of direct supports from an element of `ext` to A
`boolean`	EvidentialArgumentationFramework.`hasEvidentialSupport(BArgument argument, java.util.Collection<BArgument> ext)`	returns true if argument has evidential support from set `ext`.
`boolean`	EvidentialArgumentationFramework.`hasMinimalEvidentialSupport(BArgument argument, java.util.Collection<BArgument> ext)`	returns true if argument has minimal evidential support from set `ext`.
`abstract boolean`	AbstractBipolarFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`	checks whether argument is acceptable wrt.
`boolean`	DeductiveArgumentationFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`
`boolean`	EvidentialArgumentationFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`	return true if argument is acceptable with respect to `ext` argument is acceptable wrt.
`boolean`	NecessityArgumentationFramework.`isAcceptable(BArgument argument, java.util.Collection<BArgument> ext)`	checks whether ext defends argument a set of arguments S defends an argument a iff S u {a} is coherent and S attacks each coherent set T, which attacks a
`boolean`	DeductiveArgumentationFramework.`isAttacked(BArgument argument, java.util.Set<BArgument> argumentSet)`	returns true if some argument of argumentSet attacks argument.
`boolean`	NecessityArgumentationFramework.`isAttackedBy(java.util.Collection<BArgument> argumentSet1, java.util.Collection<BArgument> argumentSet2)`	checks whether some argument in argumentSet1 is attacked by any argument in argumentSet2
`boolean`	NecessityArgumentationFramework.`isAttackedBy(BArgument argument, java.util.Collection<BArgument> argumentSet)`	checks whether argument is attacked by any argument in argumentSet
`boolean`	DeductiveArgumentationFramework.`isAttacking(java.util.Set<BArgument> argumentSet1, java.util.Set<BArgument> argumentSet2)`	Checks whether argumentSet1 is attacking argumentSet2 ie any element of argumentSet1 is attacking any element of argumentSet2
`boolean`	DeductiveArgumentationFramework.`isAttacking(BArgument argument, java.util.Set<BArgument> argSet)`	returns true if some argument of argSet is attacked by argument.
`boolean`	NecessityArgumentationFramework.`isClosed(java.util.Collection<BArgument> argumentSet)`	checks if the given set of arguments is closed under the support relation a set of arguments S is closed iff every argument a in S has support from a non-empty subset of S
`boolean`	NecessityArgumentationFramework.`isCoherent(java.util.Collection<BArgument> argumentSet)`	checks if the set of arguments S is coherent in his argumentation framework S is coherent iff it is closed and N-Cycle-Free
`boolean`	NecessityArgumentationFramework.`isConflictFree(java.util.Collection<BArgument> argumentSet)`	checks whether the given set is conflict-free wrt.
`boolean`	EvidentialArgumentationFramework.`isEvidenceSupportedAttack(java.util.Collection<BArgument> ext, BArgument argument)`	returns true if `ext` carries out an evidence supported attack on argument ext e-support-attacks an argument a iff a subset S of ext attacks a and all elements of S have e-support from ext.
`boolean`	EvidentialArgumentationFramework.`isMinimalEvidenceSupportedAttack(java.util.Collection<BArgument> ext, BArgument argument)`	returns true if `ext` carries out a minimal evidence supported attack on argument i.e.
`boolean`	NecessityArgumentationFramework.`isNCycleFree(java.util.Collection<BArgument> argumentSet)`	checks if a set of arguments S is N-Cycle-Free in this argumentation framework ie.
`boolean`	NecessityArgumentationFramework.`isNCycleFreeIn(BArgument argument, java.util.Collection<BArgument> argumentSet)`	checks if argument is N-Cycle-Free in the set of arguments
`boolean`	NecessityArgumentationFramework.`isStronglyCoherent(java.util.Collection<BArgument> argumentSet)`	checks whether the given set of arguments is strongly coherent in this argumentation framework a set of arguments is strongly coherent iff it is coherent an conflict-free

Constructors in org.tweetyproject.arg.bipolar.syntax with parameters of type BArgument
Constructor	Description
`ArgumentSet(BArgument argument)`
`BinaryAttack(BArgument attacker, BArgument attacked)`	Default constructor; initializes the two arguments used in this attack relation
`BinarySupport(BArgument supporter, BArgument supported)`	Default constructor; initializes the two arguments used in this support relation
`SetAttack(java.util.Collection<BArgument> supporter, BArgument supported)`	initializes the arguments used in this attack relation
`SetAttack(ArgumentSet supporter, BArgument supported)`	Default constructor; initializes the arguments used in this attack relation
`SetAttack(BArgument supporter, BArgument supported)`	initializes the arguments used in this attack relation
`SetSupport(java.util.Collection<BArgument> supporter, BArgument supported)`	initializes the arguments used in this support relation
`SetSupport(ArgumentSet supporter, BArgument supported)`	Default constructor; initializes the arguments used in this support relation
`SetSupport(BArgument supporter, BArgument supported)`	initializes the arguments used in this support relation

Constructor parameters in org.tweetyproject.arg.bipolar.syntax with type arguments of type BArgument
Constructor	Description
`ArgumentSet(java.util.Collection<? extends BArgument> arguments)`
`SetAttack(java.util.Collection<BArgument> supporter, BArgument supported)`	initializes the arguments used in this attack relation
`SetSupport(java.util.Collection<BArgument> supporter, BArgument supported)`	initializes the arguments used in this support relation

Uses of Classorg.tweetyproject.arg.bipolar.syntax.BArgument

Uses of BArgument in org.tweetyproject.arg.bipolar.syntax

Uses of Class
org.tweetyproject.arg.bipolar.syntax.BArgument