Package org.tweetyproject.comparator

Class NumericalPartialOrder<T extends Formula,R extends BeliefBase>

java.lang.Object

org.tweetyproject.commons.AbstractInterpretation<R,T>

org.tweetyproject.comparator.GeneralComparator<T,R>

org.tweetyproject.comparator.NumericalPartialOrder<T,R>

Type Parameters:

T - Some Formular

R - Some Beliefbase

All Implemented Interfaces:

Comparator<T>, Map<T,Double>, Interpretation<R,T>

public class NumericalPartialOrder<T extends Formula,R extends BeliefBase>
extends GeneralComparator<T,R>
implements Map<T,Double>

This class provides an acceptability interpretation of arguments by assigning them real values. Often larger values indicate more acceptability, but some semantics use other ways of ranking the values.

Author:

Matthias Thimm, Anna Gessler

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static enum	NumericalPartialOrder.SortingType	Possible sorting types for the numerical values.

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

Field Summary

Fields

Modifier and Type	Field	Description
static double	PRECISION	Precision for comparing values.
NumericalPartialOrder.SortingType	sortingType	The method used for ordering the numerical values according to acceptability.

Constructor Summary

Constructors

Constructor	Description
NumericalPartialOrder()	Creates a new empty numerical argument ranking.
NumericalPartialOrder(Collection<T> args, double initialvalue)	Creates a new ranking with the given set of arguments and the given initial ranking value.

Method Summary

Modifier and Type	Method	Description
void	clear()
boolean	containsIncomparableArguments()	Return true if this ranking contains incomparable arguments, false otherwise
boolean	containsKey(Object arg0)
boolean	containsValue(Object arg0)
Set<Map.Entry<T,Double>>	entrySet()
Double	get(Object arg0)
NumericalPartialOrder.SortingType	getSortingType()	Return the sorting type that is used for ranking values (descending, ascending or sorted lexicographically)
boolean	isEmpty()
boolean	isIncomparable(T a, T b)	Returns "true" iff a and b are incomparable (i.e.
boolean	isStrictlyLessOrEquallyAcceptableThan(T a, T 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.
Set<T>	keySet()
Double	put(T arg0, Double arg1)
void	putAll(Map<? extends T,? extends Double> arg0)
Double	remove(Object arg0)
boolean	satisfies(R beliefBase)	Checks whether this interpretation satisfies the given knowledge base.
boolean	satisfies(T formula)	Checks whether this interpretation satisfies the given formula.
void	setSortingType(NumericalPartialOrder.SortingType sortingType)	Set the sorting type for ranking values.
int	size()
String	toString()
Collection<Double>	values()

Methods inherited from class org.tweetyproject.comparator.GeneralComparator

compare, getMaximallyAcceptedArguments, getMinimallyAcceptedArguments, isEquallyAcceptableThan, isEquivalent, isStrictlyLessAcceptableThan, isStrictlyMoreAcceptableThan, isStrictlyMoreOrEquallyAcceptableThan

Methods inherited from class org.tweetyproject.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

Methods inherited from interface java.util.Map

compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

Field Details

PRECISION

public static double PRECISION

Precision for comparing values.

sortingType

public NumericalPartialOrder.SortingType sortingType

The method used for ordering the numerical values according to acceptability.

Constructor Details

NumericalPartialOrder

public NumericalPartialOrder()

Creates a new empty numerical argument ranking.

NumericalPartialOrder

public NumericalPartialOrder(Collection<T> args,
 double initialvalue)

Creates a new ranking with the given set of arguments and the given initial ranking value.

Parameters:

args - some set of comparable elements

initialvalue - an initial value that will be assigned to all comparable elements

Method Details

isStrictlyLessOrEquallyAcceptableThan

public boolean isStrictlyLessOrEquallyAcceptableThan(T a,
 T b)

Description copied from class: GeneralComparator

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)

Specified by:

isStrictlyLessOrEquallyAcceptableThan in class GeneralComparator<T extends Formula,R extends BeliefBase>

Parameters:

a - some comparable element

b - some comparable element

Returns:

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

toString

public String toString()

Overrides:

toString in class Object

clear

public void clear()

Specified by:

clear in interface Map<T extends Formula,R extends BeliefBase>

containsKey

public boolean containsKey(Object arg0)

Specified by:

containsKey in interface Map<T extends Formula,R extends BeliefBase>

containsValue

public boolean containsValue(Object arg0)

Specified by:

containsValue in interface Map<T extends Formula,R extends BeliefBase>

entrySet

public Set<Map.Entry<T,Double>> entrySet()

Specified by:

entrySet in interface Map<T extends Formula,R extends BeliefBase>

get

public Double get(Object arg0)

Specified by:

get in interface Map<T extends Formula,R extends BeliefBase>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<T extends Formula,R extends BeliefBase>

keySet

public Set<T> keySet()

Specified by:

keySet in interface Map<T extends Formula,R extends BeliefBase>

put

public Double put(T arg0,
 Double arg1)

Specified by:

put in interface Map<T extends Formula,R extends BeliefBase>

putAll

public void putAll(Map<? extends T,? extends Double> arg0)

Specified by:

putAll in interface Map<T extends Formula,R extends BeliefBase>

remove

public Double remove(Object arg0)

Specified by:

remove in interface Map<T extends Formula,R extends BeliefBase>

size

public int size()

Specified by:

size in interface Map<T extends Formula,R extends BeliefBase>

values

public Collection<Double> values()

Specified by:

values in interface Map<T extends Formula,R extends BeliefBase>

getSortingType

public NumericalPartialOrder.SortingType getSortingType()

Return the sorting type that is used for ranking values (descending, ascending or sorted lexicographically)

Returns:

the sorting type that is used for ranking values (descending, ascending or sorted lexicographically)

setSortingType

public void setSortingType(NumericalPartialOrder.SortingType sortingType)

Set the sorting type for ranking values. For example, the "ascending" type means that smaller values signify a higher ranking than bigger values.

Parameters:

sortingType - see sortingType for a description of the available sorting methods

isIncomparable

public boolean isIncomparable(T a,
 T b)

Description copied from class: GeneralComparator

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

Specified by:

isIncomparable in class GeneralComparator<T extends Formula,R extends BeliefBase>

Parameters:

a - comparable element

b - comparable element

Returns:

"true" iff a and b are incomparable

containsIncomparableArguments

public boolean containsIncomparableArguments()

Description copied from class: GeneralComparator

Return true if this ranking contains incomparable arguments, false otherwise

Specified by:

containsIncomparableArguments in class GeneralComparator<T extends Formula,R extends BeliefBase>

Returns:

true if this ranking contains incomparable arguments, false otherwise

satisfies

public boolean satisfies(T formula)
                  throws IllegalArgumentException

Description copied from interface: Interpretation

Checks whether this interpretation satisfies the given formula.

Specified by:

satisfies in interface Interpretation<T extends Formula,R extends BeliefBase>

Parameters:

formula - a formula .

Returns:

"true" if this interpretation satisfies the given formula.

Throws:

IllegalArgumentException - if the formula does not correspond to the expected language.

satisfies

public boolean satisfies(R beliefBase)
                  throws IllegalArgumentException

Description copied from interface: Interpretation

Checks whether this interpretation satisfies the given knowledge base.

Specified by:

satisfies in interface Interpretation<T extends Formula,R extends BeliefBase>

Parameters:

beliefBase - a knowledge base.

Returns:

"true" if this interpretation satisfies the given knowledge base.

Throws:

IllegalArgumentException - IllegalArgumentException if the knowledgebase does not correspond to the expected language.