de.uka.ilkd.key.axiom_abstraction

Class AbstractDomainLattice<ConcrDomElem>

java.lang.Object

de.uka.ilkd.key.axiom_abstraction.AbstractDomainLattice<ConcrDomElem>

Type Parameters:

AbstrDomElem -

ConcrDomElem -

All Implemented Interfaces:

PartialComparator<AbstractDomainElement>, Iterable<AbstractDomainElement>

Direct Known Subclasses:

BooleanLattice, SignAnalysisLattice

public abstract class AbstractDomainLattice<ConcrDomElem>
extends Object
implements PartialComparator<AbstractDomainElement>, Iterable<AbstractDomainElement>

An abstract domain is a countable lattice with a partial order relation and a join operator. It supplies methods to abstract from a concrete domain to this abstract domain, and for iterating through the domain elements, thereby respecting the partial order.

Author:

Dominic Scheurer

Nested Class Summary

Nested classes/interfaces inherited from interface de.uka.ilkd.key.axiom_abstraction.PartialComparator

PartialComparator.PartialComparisonResult

Constructor Summary

Constructors

Constructor and Description
AbstractDomainLattice()

Method Summary

Modifier and Type	Method and Description
abstract AbstractDomainElement	abstractFrom(ConcrDomElem elem) Abstracts from a given element of the concrete domain by returning a suitable abstract element.
PartialComparator.PartialComparisonResult	compare(AbstractDomainElement a, AbstractDomainElement b) Compares its two arguments for order.
abstract Iterator<AbstractDomainElement>	iterator() Iterates through the abstract domain elements of this abstract domain starting by the smallest element; if an element b is returned by the iterator after an element a, the either compare(a,b) == LTE, or compare(a,b) == UNDEF must hold (i.e., b may not be smaller than a).
abstract AbstractDomainElement	join(AbstractDomainElement a, AbstractDomainElement b) A lattice join operation; finds an abstract element that is the least upper bound of the set consisting of the elements a and b.

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

AbstractDomainLattice

public AbstractDomainLattice()

Method Detail

abstractFrom

public abstract AbstractDomainElement abstractFrom(ConcrDomElem elem)

Abstracts from a given element of the concrete domain by returning a suitable abstract element. The returned abstract element should be as precise as possible, that is there should not be a smaller abstract element that also describes the concrete element.

Parameters:

elem - Element to abstract from.

Returns:

A suitable abstract domain element.

join

public abstract AbstractDomainElement join(AbstractDomainElement a,
                                           AbstractDomainElement b)

A lattice join operation; finds an abstract element that is the least upper bound of the set consisting of the elements a and b.

Parameters:

a - First element to find the least upper bound for.

b - Second element to find the least upper bound for.

Returns:

The least upper bound of the set consisting of the elements a and b.

compare

public PartialComparator.PartialComparisonResult compare(AbstractDomainElement a,
                                                         AbstractDomainElement b)

Description copied from interface: PartialComparator

Compares its two arguments for order. If the arguments are incomparable, UNDEF is returned. Otherwise, the method returns LTE, EQ, or GTE as the first argument is less than, equal to, or greater than the second.

Specified by:

compare in interface PartialComparator<AbstractDomainElement>

Parameters:

a - the first object to be compared.

b - the second object to be compared.

Returns:

LTE, EQ, or GTE as the first argument is less than, equal to, or greater than the second; returns UNDEF if the arguments are incomparable.

iterator

public abstract Iterator<AbstractDomainElement> iterator()

Iterates through the abstract domain elements of this abstract domain starting by the smallest element; if an element b is returned by the iterator after an element a, the either compare(a,b) == LTE, or compare(a,b) == UNDEF must hold (i.e., b may not be smaller than a).

Specified by:

iterator in interface Iterable<AbstractDomainElement>