Parma_Polyhedra_Library::Powerset< D > Class Template Reference
[C++ Language Interface]

The powerset construction on a base-level domain. More...

#include <Powerset.defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::Powerset< D >:
Inheritance graph
[legend]

List of all members.

Public Types

typedef Sequence::size_type size_type
typedef Sequence::value_type value_type
typedef iterator_to_const
< Sequence
iterator
 Alias for a read-only bidirectional iterator on the disjuncts of a Powerset element.
typedef
const_iterator_to_const
< Sequence
const_iterator
 A bidirectional const_iterator on the disjuncts of a Powerset element.
typedef std::reverse_iterator
< iterator
reverse_iterator
 The reverse iterator type built from Powerset::iterator.
typedef std::reverse_iterator
< const_iterator
const_reverse_iterator
 The reverse iterator type built from Powerset::const_iterator.

Public Member Functions

Constructors and Destructor

 Powerset ()
 Default constructor: builds the bottom of the powerset constraint system (i.e., the empty powerset).
 Powerset (const Powerset &y)
 Copy constructor.
 Powerset (const D &d)
 If d is not bottom, builds a powerset containing only d. Builds the empty powerset otherwise.
 ~Powerset ()
 Destructor.
Member Functions that Do Not Modify the Powerset Object

bool definitely_entails (const Powerset &y) const
 Returns true if *this definitely entails y. Returns false if *this may not entail y (i.e., if *this does not entail y or if entailment could not be decided).
bool is_top () const
 Returns true if and only if *this is the top element of the powerset constraint system (i.e., it represents the universe).
bool is_bottom () const
 Returns true if and only if *this is the bottom element of the powerset constraint system (i.e., it represents the empty set).
memory_size_type total_memory_in_bytes () const
 Returns a lower bound to the total size in bytes of the memory occupied by *this.
memory_size_type external_memory_in_bytes () const
 Returns a lower bound to the size in bytes of the memory managed by *this.
bool OK (bool disallow_bottom=false) const
 Checks if all the invariants are satisfied.
Member Functions for the Direct Manipulation of Disjuncts

void omega_reduce () const
 Drops from the sequence of disjuncts in *this all the non-maximal elements so that *this is non-redundant.
size_type size () const
 Returns the number of disjuncts.
bool empty () const
 Returns true if and only if there are no disjuncts in *this.
iterator begin ()
 Returns an iterator pointing to the first disjunct, if *this is not empty; otherwise, returns the past-the-end iterator.
iterator end ()
 Returns the past-the-end iterator.
const_iterator begin () const
 Returns a const_iterator pointing to the first disjunct, if *this is not empty; otherwise, returns the past-the-end const_iterator.
const_iterator end () const
 Returns the past-the-end const_iterator.
reverse_iterator rbegin ()
 Returns a reverse_iterator pointing to the last disjunct, if *this is not empty; otherwise, returns the before-the-start reverse_iterator.
reverse_iterator rend ()
 Returns the before-the-start reverse_iterator.
const_reverse_iterator rbegin () const
 Returns a const_reverse_iterator pointing to the last disjunct, if *this is not empty; otherwise, returns the before-the-start const_reverse_iterator.
const_reverse_iterator rend () const
 Returns the before-the-start const_reverse_iterator.
void add_disjunct (const D &d)
 Adds to *this the disjunct d.
iterator drop_disjunct (iterator position)
 Drops the disjunct in *this pointed to by position, returning an iterator to the disjunct following position.
void drop_disjuncts (iterator first, iterator last)
 Drops all the disjuncts from first to last (excluded).
void clear ()
 Drops all the disjuncts, making *this an empty powerset.
Member Functions that May Modify the Powerset Object

Powersetoperator= (const Powerset &y)
 The assignment operator.
void swap (Powerset &y)
 Swaps *this with y.
void least_upper_bound_assign (const Powerset &y)
 Assigns to *this the least upper bound of *this and y.
void upper_bound_assign (const Powerset &y)
 Assigns to *this an upper bound of *this and y.
bool upper_bound_assign_if_exact (const Powerset &y)
 Assigns to *this the least upper bound of *this and y and returns true.
void meet_assign (const Powerset &y)
 Assigns to *this the meet of *this and y.
void collapse ()
 If *this is not empty (i.e., it is not the bottom element), it is reduced to a singleton obtained by computing an upper-bound of all the disjuncts.

Protected Types

typedef std::list< D > Sequence
 A powerset is implemented as a sequence of elements.
typedef Sequence::iterator Sequence_iterator
 Alias for the low-level iterator on the disjuncts.
typedef Sequence::const_iterator Sequence_const_iterator
 Alias for the low-level const_iterator on the disjuncts.

Protected Member Functions

bool is_omega_reduced () const
 Returns true if and only if *this does not contain non-maximal elements.
void collapse (unsigned max_disjuncts)
 Upon return, *this will contain at most max_disjuncts elements; the set of disjuncts in positions greater than or equal to max_disjuncts, will be replaced at that position by their upper-bound.
iterator add_non_bottom_disjunct_preserve_reduction (const D &d, iterator first, iterator last)
 Adds to *this the disjunct d, assuming d is not the bottom element and ensuring partial Omega-reduction.
void add_non_bottom_disjunct_preserve_reduction (const D &d)
 Adds to *this the disjunct d, assuming d is not the bottom element and preserving Omega-reduction.
template<typename Binary_Operator_Assign >
void pairwise_apply_assign (const Powerset &y, Binary_Operator_Assign op_assign)
 Assigns to *this the result of applying op_assign pairwise to the elements in *this and y.

Protected Attributes

Sequence sequence
 The sequence container holding powerset's elements.
bool reduced
 If true, *this is Omega-reduced.

Private Member Functions

bool check_omega_reduced () const
 Does the hard work of checking whether *this contains non-maximal elements and returns true if and only if it does not.
void collapse (Sequence_iterator sink)
 Replaces the disjunct *sink by an upper bound of itself and all the disjuncts following it.

Related Functions

(Note that these are not member functions.)



template<typename D >
bool operator== (const Powerset< D > &x, const Powerset< D > &y)
 Returns true if and only if x and y are equivalent.
template<typename D >
bool operator!= (const Powerset< D > &x, const Powerset< D > &y)
 Returns true if and only if x and y are not equivalent.
template<typename D >
std::ostream & operator<< (std::ostream &s, const Powerset< D > &x)
 Output operator.
template<typename D >
void swap (Parma_Polyhedra_Library::Powerset< D > &x, Parma_Polyhedra_Library::Powerset< D > &y)
 Specializes std::swap.

Detailed Description

template<typename D>
class Parma_Polyhedra_Library::Powerset< D >

The powerset construction on a base-level domain.

This class offers a generic implementation of a powerset domain as defined in Section The Powerset Construction.

Besides invoking the available methods on the disjuncts of a Powerset, this class also provides bidirectional iterators that allow for a direct inspection of these disjuncts. For a consistent handling of Omega-reduction, all the iterators are read-only, meaning that the disjuncts cannot be overwritten. Rather, by using the class iterator, it is possible to drop one or more disjuncts (possibly so as to later add back modified versions). As an example of iterator usage, the following template function drops from powerset ps all the disjuncts that would have become redundant by the addition of an external element d.

template <typename D>
void
drop_subsumed(Powerset<D>& ps, const D& d) {
  for (typename Powerset<D>::iterator i = ps.begin(),
         ps_end = ps.end(), i != ps_end; )
    if (i->definitely_entails(d))
      i = ps.drop_disjunct(i);
    else
      ++i;
}

The template class D must provide the following methods.

    memory_size_type total_memory_in_bytes() const

Returns a lower bound on the total size in bytes of the memory occupied by the instance of D.

    bool is_top() const

Returns true if and only if the instance of D is the top element of the domain.

    bool is_bottom() const

Returns true if and only if the instance of D is the bottom element of the domain.

    bool definitely_entails(const D& y) const

Returns true if the instance of D definitely entails y. Returns false if the instance may not entail y (i.e., if the instance does not entail y or if entailment could not be decided).

    void upper_bound_assign(const D& y)

Assigns to the instance of D an upper bound of the instance and y.

    void meet_assign(const D& y)

Assigns to the instance of D the meet of the instance and y.

    bool OK() const

Returns true if the instance of D is in a consistent state, else returns false.

The following operators on the template class D must be defined.

    operator<<(std::ostream& s, const D& x)

Writes a textual representation of the instance of D on s.

    operator==(const D& x, const D& y)

Returns true if and only if x and y are equivalent D's.

    operator!=(const D& x, const D& y)

Returns true if and only if x and y are different D's.

Definition at line 147 of file Powerset.defs.hh.


Member Typedef Documentation

A bidirectional const_iterator on the disjuncts of a Powerset element.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 253 of file Powerset.defs.hh.

template<typename D>
typedef std::reverse_iterator<const_iterator> Parma_Polyhedra_Library::Powerset< D >::const_reverse_iterator

The reverse iterator type built from Powerset::const_iterator.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 259 of file Powerset.defs.hh.

Alias for a read-only bidirectional iterator on the disjuncts of a Powerset element.

By using this iterator type, the disjuncts cannot be overwritten, but they can be removed using methods drop_disjunct(iterator position) and drop_disjuncts(iterator first, iterator last), while still ensuring a correct handling of Omega-reduction.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 250 of file Powerset.defs.hh.

template<typename D>
typedef std::reverse_iterator<iterator> Parma_Polyhedra_Library::Powerset< D >::reverse_iterator

The reverse iterator type built from Powerset::iterator.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 256 of file Powerset.defs.hh.

template<typename D>
typedef std::list<D> Parma_Polyhedra_Library::Powerset< D >::Sequence [protected]

A powerset is implemented as a sequence of elements.

The particular sequence employed must support efficient deletion in any position and efficient back insertion.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 221 of file Powerset.defs.hh.

template<typename D>
typedef Sequence::const_iterator Parma_Polyhedra_Library::Powerset< D >::Sequence_const_iterator [protected]

Alias for the low-level const_iterator on the disjuncts.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 227 of file Powerset.defs.hh.

template<typename D>
typedef Sequence::iterator Parma_Polyhedra_Library::Powerset< D >::Sequence_iterator [protected]

Alias for the low-level iterator on the disjuncts.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 224 of file Powerset.defs.hh.

template<typename D>
typedef Sequence::size_type Parma_Polyhedra_Library::Powerset< D >::size_type

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 237 of file Powerset.defs.hh.

template<typename D>
typedef Sequence::value_type Parma_Polyhedra_Library::Powerset< D >::value_type

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 238 of file Powerset.defs.hh.


Constructor & Destructor Documentation

template<typename D >
Parma_Polyhedra_Library::Powerset< D >::Powerset (  )  [inline]

Default constructor: builds the bottom of the powerset constraint system (i.e., the empty powerset).

Definition at line 133 of file Powerset.inlines.hh.

00134   : sequence(), reduced(true) {
00135 }

template<typename D >
Parma_Polyhedra_Library::Powerset< D >::Powerset ( const Powerset< D > &  y  )  [inline]

Copy constructor.

Definition at line 112 of file Powerset.inlines.hh.

00113   : sequence(y.sequence), reduced(y.reduced) {
00114 }

template<typename D>
Parma_Polyhedra_Library::Powerset< D >::Powerset ( const D &  d  )  [inline, explicit]

If d is not bottom, builds a powerset containing only d. Builds the empty powerset otherwise.

Definition at line 139 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::OK(), and Parma_Polyhedra_Library::Powerset< D >::sequence.

00140   : sequence(), reduced(false) {
00141   sequence.push_back(d);
00142   PPL_ASSERT_HEAVY(OK());
00143 }

template<typename D >
Parma_Polyhedra_Library::Powerset< D >::~Powerset (  )  [inline]

Destructor.

Definition at line 147 of file Powerset.inlines.hh.

00147                        {
00148 }


Member Function Documentation

template<typename D>
void Parma_Polyhedra_Library::Powerset< D >::add_disjunct ( const D &  d  )  [inline]

Adds to *this the disjunct d.

Definition at line 159 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::reduced, and Parma_Polyhedra_Library::Powerset< D >::sequence.

00159                                     {
00160   sequence.push_back(d);
00161   reduced = false;
00162 }

template<typename D>
void Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction ( const D &  d  )  [inline, protected]

Adds to *this the disjunct d, assuming d is not the bottom element and preserving Omega-reduction.

If *this is reduced before an invocation of this method, it will be reduced upon successful return from the method.

Definition at line 152 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Powerset< D >::begin(), and Parma_Polyhedra_Library::Powerset< D >::end().

00152                                                                   {
00153   // !d.is_bottom() is asserted by the callee.
00154   add_non_bottom_disjunct_preserve_reduction(d, begin(), end());
00155 }

template<typename D>
Powerset< D >::iterator Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction ( const D &  d,
iterator  first,
iterator  last 
) [inline, protected]

Adds to *this the disjunct d, assuming d is not the bottom element and ensuring partial Omega-reduction.

If d is not the bottom element and is not Omega-redundant with respect to elements in positions between first and last, all elements in these positions that would be made Omega-redundant by the addition of d are dropped and d is added to the reduced sequence. If *this is reduced before an invocation of this method, it will be reduced upon successful return from the method.

Definition at line 151 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::drop_disjunct(), Parma_Polyhedra_Library::Powerset< D >::OK(), and Parma_Polyhedra_Library::Powerset< D >::sequence.

Referenced by Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BGP99_heuristics_assign(), Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign(), and Parma_Polyhedra_Library::Pointset_Powerset< PSET >::pairwise_reduce().

00153                                                                        {
00154   PPL_ASSERT_HEAVY(!d.is_bottom());
00155   for (iterator xi = first; xi != last; ) {
00156     const D& xv = *xi;
00157     if (d.definitely_entails(xv))
00158       return first;
00159     else if (xv.definitely_entails(d)) {
00160       if (xi == first)
00161         ++first;
00162       xi = drop_disjunct(xi);
00163     }
00164     else
00165       ++xi;
00166   }
00167   sequence.push_back(d);
00168   PPL_ASSERT_HEAVY(OK());
00169   return first;
00170 }

template<typename D >
Powerset< D >::const_iterator Parma_Polyhedra_Library::Powerset< D >::begin (  )  const [inline]

Returns a const_iterator pointing to the first disjunct, if *this is not empty; otherwise, returns the past-the-end const_iterator.

Definition at line 46 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::sequence.

00046                          {
00047   return sequence.begin();
00048 }

template<typename D >
Powerset< D >::iterator Parma_Polyhedra_Library::Powerset< D >::begin (  )  [inline]

Returns an iterator pointing to the first disjunct, if *this is not empty; otherwise, returns the past-the-end iterator.

Definition at line 34 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::sequence.

Referenced by Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::ascii_dump(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BGP99_heuristics_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BHZ03_widening_assign(), Parma_Polyhedra_Library::Powerset< D >::check_omega_reduced(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::collect_certificates(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::concatenate_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::constrains(), Parma_Polyhedra_Library::Powerset< D >::definitely_entails(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::difference_assign(), Parma_Polyhedra_Library::Powerset< D >::external_memory_in_bytes(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::geometrically_covers(), Parma_Polyhedra_Library::Powerset< D >::is_top(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_universe(), Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign(), Parma_Polyhedra_Library::Powerset< D >::OK(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::OK(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), Parma_Polyhedra_Library::Powerset< D >::operator==(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::pairwise_reduce(), and Parma_Polyhedra_Library::Powerset< D >::rend().

00034                    {
00035   return sequence.begin();
00036 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::check_omega_reduced (  )  const [inline, private]

Does the hard work of checking whether *this contains non-maximal elements and returns true if and only if it does not.

Definition at line 124 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), and Parma_Polyhedra_Library::Powerset< D >::end().

Referenced by Parma_Polyhedra_Library::Powerset< D >::is_omega_reduced(), and Parma_Polyhedra_Library::Powerset< D >::OK().

00124                                        {
00125   for (const_iterator x_begin = begin(), x_end = end(),
00126          xi = x_begin; xi != x_end; ++xi) {
00127     const D& xv = *xi;
00128     if (xv.is_bottom())
00129       return false;
00130     for (const_iterator yi = x_begin; yi != x_end; ++yi) {
00131       if (xi == yi)
00132         continue;
00133       const D& yv = *yi;
00134       if (xv.definitely_entails(yv) || yv.definitely_entails(xv))
00135         return false;
00136     }
00137   }
00138   return true;
00139 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::clear (  )  [inline]

Drops all the disjuncts, making *this an empty powerset.

Definition at line 106 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::sequence.

00106                    {
00107   sequence.clear();
00108 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::collapse ( Sequence_iterator  sink  )  [inline, private]

Replaces the disjunct *sink by an upper bound of itself and all the disjuncts following it.

Definition at line 36 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::drop_disjunct(), Parma_Polyhedra_Library::Powerset< D >::drop_disjuncts(), Parma_Polyhedra_Library::Powerset< D >::end(), Parma_Polyhedra_Library::Powerset< D >::OK(), and Parma_Polyhedra_Library::Powerset< D >::sequence.

00036                                                   {
00037   PPL_ASSERT(sink != sequence.end());
00038   D& d = *sink;
00039   iterator x_sink = sink;
00040   iterator next_x_sink = x_sink;
00041   ++next_x_sink;
00042   iterator x_end = end();
00043   for (const_iterator xi = next_x_sink; xi != x_end; ++xi)
00044     d.upper_bound_assign(*xi);
00045   // Drop the surplus disjuncts.
00046   drop_disjuncts(next_x_sink, x_end);
00047 
00048   // Ensure omega-reduction.
00049   for (iterator xi = begin(); xi != x_sink; )
00050     if (xi->definitely_entails(d))
00051       xi = drop_disjunct(xi);
00052     else
00053       ++xi;
00054 
00055   PPL_ASSERT_HEAVY(OK());
00056 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::collapse ( unsigned  max_disjuncts  )  [inline, protected]

Upon return, *this will contain at most max_disjuncts elements; the set of disjuncts in positions greater than or equal to max_disjuncts, will be replaced at that position by their upper-bound.

Definition at line 105 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::iterator_to_const< Container >::base, Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Powerset< D >::is_omega_reduced(), Parma_Polyhedra_Library::Powerset< D >::OK(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), and Parma_Polyhedra_Library::Powerset< D >::size().

00105                                                   {
00106   PPL_ASSERT(max_disjuncts > 0);
00107   // Omega-reduce before counting the number of disjuncts.
00108   omega_reduce();
00109   size_type n = size();
00110   if (n > max_disjuncts) {
00111     // Let `i' point to the last disjunct that will survive.
00112     iterator i = begin();
00113     std::advance(i, max_disjuncts-1);
00114     // This disjunct will be assigned an upper-bound of itself and of
00115     // all the disjuncts that follow.
00116     collapse(i.base);
00117   }
00118   PPL_ASSERT_HEAVY(OK());
00119   PPL_ASSERT(is_omega_reduced());
00120 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::collapse (  )  [inline]

If *this is not empty (i.e., it is not the bottom element), it is reduced to a singleton obtained by computing an upper-bound of all the disjuncts.

Definition at line 191 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::empty(), and Parma_Polyhedra_Library::Powerset< D >::sequence.

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BGP99_extrapolation_assign(), Parma_Polyhedra_Library::Powerset< D >::collapse(), and Parma_Polyhedra_Library::Powerset< D >::omega_reduce().

00191                       {
00192   if (!empty())
00193     collapse(sequence.begin());
00194 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::definitely_entails ( const Powerset< D > &  y  )  const [inline]

Returns true if *this definitely entails y. Returns false if *this may not entail y (i.e., if *this does not entail y or if entailment could not be decided).

Definition at line 174 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), and Parma_Polyhedra_Library::Powerset< D >::end().

00174                                                        {
00175   const Powerset<D>& x = *this;
00176   bool found = true;
00177   for (const_iterator xi = x.begin(),
00178          x_end = x.end(); found && xi != x_end; ++xi) {
00179     found = false;
00180     for (const_iterator yi = y.begin(),
00181            y_end = y.end(); !found && yi != y_end; ++yi)
00182       found = (*xi).definitely_entails(*yi);
00183   }
00184   return found;
00185 }

template<typename D >
Powerset< D >::iterator Parma_Polyhedra_Library::Powerset< D >::drop_disjunct ( iterator  position  )  [inline]
template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::drop_disjuncts ( iterator  first,
iterator  last 
) [inline]

Drops all the disjuncts from first to last (excluded).

Definition at line 100 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::iterator_to_const< Container >::base, and Parma_Polyhedra_Library::Powerset< D >::sequence.

Referenced by Parma_Polyhedra_Library::Powerset< D >::collapse().

00100                                                          {
00101   sequence.erase(first.base, last.base);
00102 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::empty (  )  const [inline]

Returns true if and only if there are no disjuncts in *this.

Definition at line 88 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::sequence.

Referenced by Parma_Polyhedra_Library::Powerset< D >::collapse(), and Parma_Polyhedra_Library::Powerset< D >::is_bottom().

00088                          {
00089   return sequence.empty();
00090 }

template<typename D >
Powerset< D >::const_iterator Parma_Polyhedra_Library::Powerset< D >::end (  )  const [inline]

Returns the past-the-end const_iterator.

Definition at line 52 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::sequence.

00052                        {
00053   return sequence.end();
00054 }

template<typename D >
Powerset< D >::iterator Parma_Polyhedra_Library::Powerset< D >::end (  )  [inline]

Returns the past-the-end iterator.

Definition at line 40 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::sequence.

Referenced by Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::ascii_dump(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BGP99_heuristics_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BHZ03_widening_assign(), Parma_Polyhedra_Library::Powerset< D >::check_omega_reduced(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::collect_certificates(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::concatenate_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::constrains(), Parma_Polyhedra_Library::Powerset< D >::definitely_entails(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::difference_assign(), Parma_Polyhedra_Library::Powerset< D >::external_memory_in_bytes(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::geometrically_covers(), Parma_Polyhedra_Library::Powerset< D >::is_top(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_universe(), Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign(), Parma_Polyhedra_Library::Powerset< D >::OK(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::OK(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), Parma_Polyhedra_Library::Powerset< D >::operator==(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::pairwise_reduce(), and Parma_Polyhedra_Library::Powerset< D >::rbegin().

00040                  {
00041   return sequence.end();
00042 }

template<typename D >
memory_size_type Parma_Polyhedra_Library::Powerset< D >::external_memory_in_bytes (  )  const [inline]

Returns a lower bound to the size in bytes of the memory managed by *this.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 272 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), and Parma_Polyhedra_Library::Powerset< D >::end().

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::external_memory_in_bytes(), and Parma_Polyhedra_Library::Powerset< D >::total_memory_in_bytes().

00272                                             {
00273   memory_size_type bytes = 0;
00274   for (const_iterator xi = begin(), x_end = end(); xi != x_end; ++xi) {
00275     bytes += xi->total_memory_in_bytes();
00276     // We assume there is at least a forward and a backward link, and
00277     // that the pointers implementing them are at least the size of
00278     // pointers to `D'.
00279     bytes += 2*sizeof(D*);
00280   }
00281   return bytes;
00282 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::is_bottom (  )  const [inline]

Returns true if and only if *this is the bottom element of the powerset constraint system (i.e., it represents the empty set).

Definition at line 183 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::empty(), and Parma_Polyhedra_Library::Powerset< D >::omega_reduce().

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::map_space_dimensions().

00183                              {
00184   // Must perform omega-reduction for correctness.
00185   omega_reduce();
00186   return empty();
00187 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::is_omega_reduced (  )  const [inline, protected]
template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::is_top (  )  const [inline]

Returns true if and only if *this is the top element of the powerset constraint system (i.e., it represents the universe).

Definition at line 173 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::end(), and Parma_Polyhedra_Library::Powerset< D >::omega_reduce().

00173                           {
00174   // Must perform omega-reduction for correctness.
00175   omega_reduce();
00176   const_iterator xi = begin();
00177   const_iterator x_end = end();
00178   return xi != x_end && xi->is_top() && ++xi == x_end;
00179 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign ( const Powerset< D > &  y  )  [inline]

Assigns to *this the least upper bound of *this and y.

Definition at line 235 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::end(), Parma_Polyhedra_Library::Powerset< D >::OK(), and Parma_Polyhedra_Library::Powerset< D >::omega_reduce().

Referenced by Parma_Polyhedra_Library::Powerset< D >::upper_bound_assign(), and Parma_Polyhedra_Library::Powerset< D >::upper_bound_assign_if_exact().

00235                                                        {
00236   // Ensure omega-reduction here, since what follows has quadratic complexity.
00237   omega_reduce();
00238   y.omega_reduce();
00239   iterator old_begin = begin();
00240   iterator old_end = end();
00241   for (const_iterator i = y.begin(), y_end = y.end(); i != y_end; ++i)
00242     old_begin = add_non_bottom_disjunct_preserve_reduction(*i,
00243                                                            old_begin,
00244                                                            old_end);
00245   PPL_ASSERT_HEAVY(OK());
00246 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::meet_assign ( const Powerset< D > &  y  )  [inline]

Assigns to *this the meet of *this and y.

Definition at line 198 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign().

00198                                           {
00199   pairwise_apply_assign(y, std::mem_fun_ref(&D::meet_assign));
00200 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::OK ( bool  disallow_bottom = false  )  const [inline]

Checks if all the invariants are satisfied.

Definition at line 286 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::check_omega_reduced(), Parma_Polyhedra_Library::Powerset< D >::end(), and Parma_Polyhedra_Library::Powerset< D >::reduced.

Referenced by Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), and Parma_Polyhedra_Library::Powerset< D >::Powerset().

00286                                                 {
00287   for (const_iterator xi = begin(), x_end = end(); xi != x_end; ++xi) {
00288     if (!xi->OK())
00289       return false;
00290     if (disallow_bottom && xi->is_bottom()) {
00291 #ifndef NDEBUG
00292       std::cerr << "Bottom element in powerset!"
00293                 << std::endl;
00294 #endif
00295       return false;
00296     }
00297   }
00298   if (reduced && !check_omega_reduced()) {
00299 #ifndef NDEBUG
00300     std::cerr << "Powerset claims to be reduced, but it is not!"
00301               << std::endl;
00302 #endif
00303     return false;
00304   }
00305   return true;
00306 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::omega_reduce (  )  const [inline]

Drops from the sequence of disjuncts in *this all the non-maximal elements so that *this is non-redundant.

This method is declared const because, even though Omega-reduction may change the syntactic representation of *this, its semantics will be unchanged.

Definition at line 60 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::abandon_expensive_computations, Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Powerset< D >::drop_disjunct(), Parma_Polyhedra_Library::Powerset< D >::end(), Parma_Polyhedra_Library::Powerset< D >::OK(), and Parma_Polyhedra_Library::Powerset< D >::reduced.

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounds_from_above(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounds_from_below(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::concatenate_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::constrains(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::difference_assign(), Parma_Polyhedra_Library::Powerset< D >::is_bottom(), Parma_Polyhedra_Library::Powerset< D >::is_top(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_topologically_closed(), Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::maximize(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::minimize(), Parma_Polyhedra_Library::Powerset< D >::operator==(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::pairwise_reduce(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::simplify_using_context_assign(), and Parma_Polyhedra_Library::Pointset_Powerset< PSET >::strictly_contains().

00060                                 {
00061   if (reduced)
00062     return;
00063 
00064   Powerset& x = const_cast<Powerset&>(*this);
00065   // First remove all bottom elements.
00066   for (iterator xi = x.begin(), x_end = x.end(); xi != x_end; )
00067     if (xi->is_bottom())
00068       xi = x.drop_disjunct(xi);
00069     else
00070       ++xi;
00071   // Then remove non-maximal elements.
00072   for (iterator xi = x.begin(); xi != x.end(); ) {
00073     const D& xv = *xi;
00074     bool dropping_xi = false;
00075     for (iterator yi = x.begin(); yi != x.end(); )
00076       if (xi == yi)
00077         ++yi;
00078       else {
00079         const D& yv = *yi;
00080         if (yv.definitely_entails(xv))
00081           yi = x.drop_disjunct(yi);
00082         else if (xv.definitely_entails(yv)) {
00083           dropping_xi = true;
00084           break;
00085         }
00086         else
00087           ++yi;
00088       }
00089     if (dropping_xi)
00090       xi = x.drop_disjunct(xi);
00091     else
00092       ++xi;
00093     if (abandon_expensive_computations && xi != x.end()) {
00094       // Hurry up!
00095       x.collapse(xi.base);
00096       break;
00097     }
00098   }
00099   reduced = true;
00100   PPL_ASSERT_HEAVY(OK());
00101 }

template<typename D >
Powerset< D > & Parma_Polyhedra_Library::Powerset< D >::operator= ( const Powerset< D > &  y  )  [inline]

The assignment operator.

Definition at line 118 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::reduced, and Parma_Polyhedra_Library::Powerset< D >::sequence.

00118                                         {
00119   sequence = y.sequence;
00120   reduced = y.reduced;
00121   return *this;
00122 }

template<typename D >
template<typename Binary_Operator_Assign >
void Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign ( const Powerset< D > &  y,
Binary_Operator_Assign  op_assign 
) [inline, protected]

Assigns to *this the result of applying op_assign pairwise to the elements in *this and y.

The elements of the powerset result are obtained by applying op_assign to each pair of elements whose components are drawn from *this and y, respectively.

Definition at line 213 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::end(), Parma_Polyhedra_Library::Powerset< D >::OK(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), Parma_Polyhedra_Library::Powerset< D >::reduced, Parma_Polyhedra_Library::Powerset< D >::sequence, and Parma_Polyhedra_Library::Powerset< D >::swap().

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::intersection_assign(), Parma_Polyhedra_Library::Powerset< D >::meet_assign(), and Parma_Polyhedra_Library::Pointset_Powerset< PSET >::time_elapse_assign().

00214                                                                      {
00215   // Ensure omega-reduction here, since what follows has quadratic complexity.
00216   omega_reduce();
00217   y.omega_reduce();
00218   Sequence new_sequence;
00219   for (const_iterator xi = begin(), x_end = end(),
00220          y_begin = y.begin(), y_end = y.end(); xi != x_end; ++xi)
00221     for (const_iterator yi = y_begin; yi != y_end; ++yi) {
00222       D zi = *xi;
00223       op_assign(zi, *yi);
00224       if (!zi.is_bottom())
00225         new_sequence.push_back(zi);
00226     }
00227   // Put the new sequence in place.
00228   std::swap(sequence, new_sequence);
00229   reduced = false;
00230   PPL_ASSERT_HEAVY(OK());
00231 }

template<typename D >
Powerset< D >::const_reverse_iterator Parma_Polyhedra_Library::Powerset< D >::rbegin (  )  const [inline]

Returns a const_reverse_iterator pointing to the last disjunct, if *this is not empty; otherwise, returns the before-the-start const_reverse_iterator.

Definition at line 70 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::end().

00070                           {
00071   return const_reverse_iterator(end());
00072 }

template<typename D >
Powerset< D >::reverse_iterator Parma_Polyhedra_Library::Powerset< D >::rbegin (  )  [inline]

Returns a reverse_iterator pointing to the last disjunct, if *this is not empty; otherwise, returns the before-the-start reverse_iterator.

Definition at line 58 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::end().

00058                     {
00059   return reverse_iterator(end());
00060 }

template<typename D >
Powerset< D >::const_reverse_iterator Parma_Polyhedra_Library::Powerset< D >::rend (  )  const [inline]

Returns the before-the-start const_reverse_iterator.

Definition at line 76 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin().

00076                         {
00077   return const_reverse_iterator(begin());
00078 }

template<typename D >
Powerset< D >::reverse_iterator Parma_Polyhedra_Library::Powerset< D >::rend (  )  [inline]

Returns the before-the-start reverse_iterator.

Definition at line 64 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin().

00064                   {
00065   return reverse_iterator(begin());
00066 }

template<typename D >
Powerset< D >::size_type Parma_Polyhedra_Library::Powerset< D >::size (  )  const [inline]
template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::swap ( Powerset< D > &  y  )  [inline]
template<typename D >
memory_size_type Parma_Polyhedra_Library::Powerset< D >::total_memory_in_bytes (  )  const [inline]

Returns a lower bound to the total size in bytes of the memory occupied by *this.

Reimplemented in Parma_Polyhedra_Library::Pointset_Powerset< PSET >.

Definition at line 217 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::external_memory_in_bytes().

00217                                          {
00218   return sizeof(*this) + external_memory_in_bytes();
00219 }

template<typename D >
void Parma_Polyhedra_Library::Powerset< D >::upper_bound_assign ( const Powerset< D > &  y  )  [inline]

Assigns to *this an upper bound of *this and y.

The result will be the least upper bound of *this and y.

Definition at line 204 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign().

00204                                                  {
00205   least_upper_bound_assign(y);
00206 }

template<typename D >
bool Parma_Polyhedra_Library::Powerset< D >::upper_bound_assign_if_exact ( const Powerset< D > &  y  )  [inline]

Assigns to *this the least upper bound of *this and y and returns true.

Exceptions:
std::invalid_argument Thrown if *this and y are dimension-incompatible.

Definition at line 210 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::least_upper_bound_assign().

00210                                                           {
00211   least_upper_bound_assign(y);
00212   return true;
00213 }


Friends And Related Function Documentation

template<typename D >
bool operator!= ( const Powerset< D > &  x,
const Powerset< D > &  y 
) [related]

Returns true if and only if x and y are not equivalent.

Definition at line 167 of file Powerset.inlines.hh.

00167                                                             {
00168   return !(x == y);
00169 }

template<typename D >
std::ostream & operator<< ( std::ostream &  s,
const Powerset< D > &  x 
) [related]

Output operator.

Definition at line 253 of file Powerset.templates.hh.

00253                                                 {
00254   if (x.is_bottom())
00255     s << "false";
00256   else if (x.is_top())
00257     s << "true";
00258   else
00259     for (typename Powerset<D>::const_iterator i = x.begin(),
00260            x_end = x.end(); i != x_end; ) {
00261       s << "{ " << *i++ << " }";
00262       if (i != x_end)
00263         s << ", ";
00264     }
00265   return s;
00266 }

template<typename D >
bool operator== ( const Powerset< D > &  x,
const Powerset< D > &  y 
) [related]

Returns true if and only if x and y are equivalent.

Definition at line 190 of file Powerset.templates.hh.

References Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Powerset< D >::drop_disjunct(), Parma_Polyhedra_Library::Powerset< D >::end(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), and Parma_Polyhedra_Library::Powerset< D >::size().

00190                                                        {
00191   x.omega_reduce();
00192   y.omega_reduce();
00193   if (x.size() != y.size())
00194     return false;
00195   // Take a copy of `y' and work with it.
00196   Powerset<D> yy = y;
00197   for (typename Powerset<D>::const_iterator xi = x.begin(),
00198          x_end = x.end(); xi != x_end; ++xi) {
00199     typename Powerset<D>::iterator yyi = yy.begin();
00200     typename Powerset<D>::iterator yy_end = yy.end();
00201     yyi = std::find(yyi, yy_end, *xi);
00202     if (yyi == yy_end)
00203       return false;
00204     else
00205       yy.drop_disjunct(yyi);
00206   }
00207   return true;
00208 }

template<typename D >
void swap ( Parma_Polyhedra_Library::Powerset< D > &  x,
Parma_Polyhedra_Library::Powerset< D > &  y 
) [related]

Specializes std::swap.

Definition at line 229 of file Powerset.inlines.hh.

References Parma_Polyhedra_Library::Powerset< D >::swap().

00230                                             {
00231   x.swap(y);
00232 }


Member Data Documentation

template<typename D>
bool Parma_Polyhedra_Library::Powerset< D >::reduced [mutable, protected]

If true, *this is Omega-reduced.

Definition at line 233 of file Powerset.defs.hh.

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_congruence(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_congruences(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_constraint(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_constraints(), Parma_Polyhedra_Library::Powerset< D >::add_disjunct(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_disjunct(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_preimage(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounded_affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounded_affine_preimage(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::difference_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::drop_some_non_integer_points(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::generalized_affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::generalized_affine_preimage(), Parma_Polyhedra_Library::Powerset< D >::is_omega_reduced(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::map_space_dimensions(), Parma_Polyhedra_Library::Powerset< D >::OK(), Parma_Polyhedra_Library::Powerset< D >::omega_reduce(), Parma_Polyhedra_Library::Powerset< D >::operator=(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::Pointset_Powerset(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_congruence(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_congruences(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_constraint(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_constraints(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::remove_higher_space_dimensions(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::remove_space_dimensions(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::simplify_using_context_assign(), Parma_Polyhedra_Library::Powerset< D >::swap(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::unconstrain(), and Parma_Polyhedra_Library::Pointset_Powerset< PSET >::wrap_assign().

template<typename D>
Sequence Parma_Polyhedra_Library::Powerset< D >::sequence [protected]

The sequence container holding powerset's elements.

Definition at line 230 of file Powerset.defs.hh.

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_congruence(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_congruences(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_constraint(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_constraints(), Parma_Polyhedra_Library::Powerset< D >::add_disjunct(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_disjunct(), Parma_Polyhedra_Library::Powerset< D >::add_non_bottom_disjunct_preserve_reduction(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_space_dimensions_and_embed(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::add_space_dimensions_and_project(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_dimension(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::affine_preimage(), Parma_Polyhedra_Library::Powerset< D >::begin(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::BGP99_heuristics_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounded_affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounded_affine_preimage(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounds_from_above(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::bounds_from_below(), Parma_Polyhedra_Library::Powerset< D >::clear(), Parma_Polyhedra_Library::Powerset< D >::collapse(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::contains(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::contains_integer_point(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::difference_assign(), Parma_Polyhedra_Library::Powerset< D >::drop_disjunct(), Parma_Polyhedra_Library::Powerset< D >::drop_disjuncts(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::drop_some_non_integer_points(), Parma_Polyhedra_Library::Powerset< D >::empty(), Parma_Polyhedra_Library::Powerset< D >::end(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::expand_space_dimension(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::fold_space_dimensions(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::generalized_affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::generalized_affine_preimage(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::intersection_preserving_enlarge_element(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_bounded(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_discrete(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_disjoint_from(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_empty(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::is_topologically_closed(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::map_space_dimensions(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::maximize(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::minimize(), Parma_Polyhedra_Library::Powerset< D >::operator=(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::pairwise_reduce(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::Pointset_Powerset(), Parma_Polyhedra_Library::Powerset< D >::Powerset(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_congruence(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_congruences(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_constraint(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::refine_with_constraints(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::relation_with(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::remove_higher_space_dimensions(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::remove_space_dimensions(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::simplify_using_context_assign(), Parma_Polyhedra_Library::Powerset< D >::size(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::strictly_contains(), Parma_Polyhedra_Library::Powerset< D >::swap(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::topological_closure_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::unconstrain(), and Parma_Polyhedra_Library::Pointset_Powerset< PSET >::wrap_assign().


The documentation for this class was generated from the following files:
Generated on Sun Feb 27 16:20:29 2011 for PPL by  doxygen 1.6.3