Package org.tweetyproject.arg.rankings.semantics

Class ArgumentRanking

java.lang.Object
org.tweetyproject.commons.AbstractInterpretation<T,Argument>
org.tweetyproject.arg.dung.semantics.AbstractArgumentationInterpretation<DungTheory>
org.tweetyproject.arg.rankings.semantics.ArgumentRanking
All Implemented Interfaces:
Comparator<Argument>, Interpretation<DungTheory,Argument>
Direct Known Subclasses:
LatticeArgumentRanking, NumericalArgumentRanking
public abstract class ArgumentRanking extends AbstractArgumentationInterpretation<DungTheory> implements 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 Details

    • ArgumentRanking

      public ArgumentRanking()

  • Method Details

    • compare

      public int compare(Argument arg0, Argument arg1)
      Specified by:
      compare in interface 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 Collection<Argument> getMaximallyAcceptedArguments(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 Collection<Argument> getMinimallyAcceptedArguments(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, 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