Package net.sf.tweety.arg.rankings.semantics

Class ArgumentRanking

java.lang.Object

net.sf.tweety.commons.AbstractInterpretation<DungTheory,Argument>

net.sf.tweety.arg.dung.semantics.AbstractArgumentationInterpretation

net.sf.tweety.arg.rankings.semantics.ArgumentRanking

All Implemented Interfaces:

java.util.Comparator<Argument>, Interpretation<DungTheory,Argument>

Direct Known Subclasses:

LatticeArgumentRanking, NumericalArgumentRanking

public abstract class ArgumentRanking
extends AbstractArgumentationInterpretation
implements java.util.Comparator<Argument>

This abstract class is the common ancestor for semantical approaches to argument ranking, i.e. relations that allow a more fine-grained comparison by e.g. utilizing numerical values for arguments.

Author:

Matthias Thimm

Constructor Summary

Constructors

Constructor	Description
ArgumentRanking()

Method Summary

Modifier and Type	Method	Description
int	compare(Argument arg0, Argument arg1)
abstract boolean	containsIncomparableArguments()
java.util.Collection<Argument>	getMaximallyAcceptedArguments(java.util.Collection<Argument> args)	Returns the set of all arguments a from the given set that are maximally accepted, i.e.
java.util.Collection<Argument>	getMinimallyAcceptedArguments(java.util.Collection<Argument> args)	Returns the set of all arguments a from the given set that are minimally accepted, i.e.
boolean	isEquallyAcceptableThan(Argument a, Argument b)	Returns "true" iff a is equally acceptable as b, i.e.
boolean	isEquivalent(ArgumentRanking other, java.util.Collection<Argument> args)	Checks whether this ranking is equivalent to the other one wrt.
abstract boolean	isIncomparable(Argument a, Argument b)	Returns "true" iff a and b are incomparable (i.e.
boolean	isStrictlyLessAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly less acceptable than b, i.e.
abstract boolean	isStrictlyLessOrEquallyAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly less acceptable than b or a is equally acceptable as b or a and b are not comparable, i.e.
boolean	isStrictlyMoreAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly more acceptable than b, i.e.
boolean	isStrictlyMoreOrEquallyAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly more acceptable than b or a is equally acceptable as b, i.e.

Methods inherited from class net.sf.tweety.arg.dung.semantics.AbstractArgumentationInterpretation

getArgumentsOfStatus, isAcceptable, isAdmissable, isConflictFree, satisfies, satisfies, toString

Methods inherited from class net.sf.tweety.commons.AbstractInterpretation

satisfies

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Comparator

equals, reversed, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

Constructor Detail

ArgumentRanking

public ArgumentRanking()

Method Detail

compare

public int compare(Argument arg0,
                   Argument arg1)

Specified by:

compare in interface java.util.Comparator<Argument>

isStrictlyMoreAcceptableThan

public boolean isStrictlyMoreAcceptableThan(Argument a,
                                            Argument b)

Returns "true" iff a is strictly more acceptable than b, i.e. a < b (least arguments are maximally acceptable arguments)

Parameters:

a - some argument

b - some argument

Returns:

"true" iff a is strictly more acceptable than b

isStrictlyLessAcceptableThan

public boolean isStrictlyLessAcceptableThan(Argument a,
                                            Argument b)

Returns "true" iff a is strictly less acceptable than b, i.e. a > b (least arguments are maximally acceptable arguments)

Parameters:

a - some argument

b - some argument

Returns:

"true" iff a is strictly less acceptable than b

isStrictlyMoreOrEquallyAcceptableThan

public boolean isStrictlyMoreOrEquallyAcceptableThan(Argument a,
                                                     Argument b)

Returns "true" iff a is strictly more acceptable than b or a is equally acceptable as b, i.e. a <= b (or a ~ b) (least arguments are maximally acceptable arguments)

Parameters:

a - some argument

b - some argument

Returns:

"true" iff a is strictly more acceptable than b or a is equally acceptable as b, "false" otherwise or if a and b are incomparable

isEquallyAcceptableThan

public boolean isEquallyAcceptableThan(Argument a,
                                       Argument b)

Returns "true" iff a is equally acceptable as b, i.e. a = b (or a ~ b) (least arguments are maximally acceptable arguments)

Parameters:

a - some argument

b - some argument

Returns:

"true" iff a is equally acceptable as b, "false" otherwise or if a and b are incomparable

getMaximallyAcceptedArguments

public java.util.Collection<Argument> getMaximallyAcceptedArguments(java.util.Collection<Argument> args)

Returns the set of all arguments a from the given set that are maximally accepted, i.e. where there is no other argument that is strictly more acceptable.

Parameters:

args - a set of arguments

Returns:

the set of all arguments a that are maximally accepted

getMinimallyAcceptedArguments

public java.util.Collection<Argument> getMinimallyAcceptedArguments(java.util.Collection<Argument> args)

Returns the set of all arguments a from the given set that are minimally accepted, i.e. where there is no other argument that is strictly less acceptable.

Parameters:

args - a set of arguments

Returns:

the set of all arguments a that are minimalle accepted

isEquivalent

public boolean isEquivalent(ArgumentRanking other,
                            java.util.Collection<Argument> args)

Checks whether this ranking is equivalent to the other one wrt. the given set of arguments.

Parameters:

other - some ranking

args - some arguments

Returns:

"true" if both rankings are equivalent.

isStrictlyLessOrEquallyAcceptableThan

public abstract boolean isStrictlyLessOrEquallyAcceptableThan(Argument a,
                                                              Argument b)

Returns "true" iff a is strictly less acceptable than b or a is equally acceptable as b or a and b are not comparable, i.e. a >= b (or a ~ b) (least arguments are maximally acceptable arguments)

Parameters:

a - some argument

b - some argument

Returns:

"true" iff a is strictly less acceptable than b or a is equally acceptable as b

isIncomparable

public abstract boolean isIncomparable(Argument a,
                                       Argument b)

Returns "true" iff a and b are incomparable (i.e. this ranking is a partial ranking).

Parameters:

a - Argument

b - Argument

Returns:

"true" iff a and b are incomparable

containsIncomparableArguments

public abstract boolean containsIncomparableArguments()

Returns:

true if this ranking contains incomparable arguments, false otherwise