Package tools.refinery.logic.term.abstractdomain

Class AbstractDomainTerms

java.lang.Object

tools.refinery.logic.term.abstractdomain.AbstractDomainTerms

public final class AbstractDomainTerms
extends Object

Method Summary

Modifier and Type	Method	Description
static <A extends AbstractValue<A, C>, C> Term<StringValue>	asString(AbstractDomain<A,C> abstractDomain, Term<A> body)
static <A extends AbstractValue<A, C>, C> Term<TruthValue>	eq(AbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends AbstractValue<A, C>, C> Term<A>	error(AbstractDomain<A,C> abstractDomain)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<TruthValue>	greater(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<TruthValue>	greaterEq(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends AbstractValue<A, C>, C> Term<Boolean>	isConcrete(AbstractDomain<A,C> abstractDomain, Term<A> body)
static <A extends AbstractValue<A, C>, C> Term<Boolean>	isError(AbstractDomain<A,C> abstractDomain, Term<A> body)
static <A extends AbstractValue<A, C>, C> Term<A>	join(AbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<TruthValue>	less(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<TruthValue>	lessEq(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	lowerBound(ComparableAbstractDomain<A,C> abstractDomain, Term<A> body)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	max(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> PartialAggregator<A,C,A,C>	maxAggregator(ComparableAbstractDomain<A,C> domain)
static <A extends AbstractValue<A, C>, C> Term<A>	meet(AbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	min(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> PartialAggregator<A,C,A,C>	minAggregator(ComparableAbstractDomain<A,C> domain)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	negativeInfinity(ComparableAbstractDomain<A,C> abstractDomain)
static <A extends AbstractValue<A, C>, C> Term<TruthValue>	notEq(AbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	positiveInfinity(ComparableAbstractDomain<A,C> abstractDomain)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	range(ComparableAbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends AbstractValue<A, C>, C> Term<Boolean>	subset(AbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends AbstractValue<A, C>, C> Term<Boolean>	superset(AbstractDomain<A,C> abstractDomain, Term<A> left, Term<A> right)
static <A extends AbstractValue<A, C>, C> Term<A>	unknown(AbstractDomain<A,C> abstractDomain)
static <A extends ComparableAbstractValue<A, C>, C extends Comparable<C>> Term<A>	upperBound(ComparableAbstractDomain<A,C> abstractDomain, Term<A> body)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

minAggregator

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
PartialAggregator<A,C,A,C> minAggregator(ComparableAbstractDomain<A,C> domain)

maxAggregator

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
PartialAggregator<A,C,A,C> maxAggregator(ComparableAbstractDomain<A,C> domain)

unknown

public static <A extends AbstractValue<A,
C>,
C>
Term<A> unknown(AbstractDomain<A,C> abstractDomain)

error

public static <A extends AbstractValue<A,
C>,
C>
Term<A> error(AbstractDomain<A,C> abstractDomain)

eq

public static <A extends AbstractValue<A,
C>,
C>
Term<TruthValue> eq(AbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

notEq

public static <A extends AbstractValue<A,
C>,
C>
Term<TruthValue> notEq(AbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

subset

public static <A extends AbstractValue<A,
C>,
C>
Term<Boolean> subset(AbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

superset

public static <A extends AbstractValue<A,
C>,
C>
Term<Boolean> superset(AbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

join

public static <A extends AbstractValue<A,
C>,
C>
Term<A> join(AbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

meet

public static <A extends AbstractValue<A,
C>,
C>
Term<A> meet(AbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

isError

public static <A extends AbstractValue<A,
C>,
C>
Term<Boolean> isError(AbstractDomain<A,C> abstractDomain,
 Term<A> body)

isConcrete

public static <A extends AbstractValue<A,
C>,
C>
Term<Boolean> isConcrete(AbstractDomain<A,C> abstractDomain,
 Term<A> body)

negativeInfinity

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> negativeInfinity(ComparableAbstractDomain<A,C> abstractDomain)

positiveInfinity

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> positiveInfinity(ComparableAbstractDomain<A,C> abstractDomain)

less

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<TruthValue> less(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

lessEq

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<TruthValue> lessEq(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

greater

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<TruthValue> greater(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

greaterEq

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<TruthValue> greaterEq(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

range

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> range(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

min

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> min(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

max

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> max(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> left,
 Term<A> right)

lowerBound

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> lowerBound(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> body)

upperBound

public static <A extends ComparableAbstractValue<A,
C>,
C extends Comparable<C>>
Term<A> upperBound(ComparableAbstractDomain<A,C> abstractDomain,
 Term<A> body)

asString

public static <A extends AbstractValue<A,
C>,
C>
Term<StringValue> asString(AbstractDomain<A,C> abstractDomain,
 Term<A> body)