Implementation related data and functions. More...

Namespaces
	BD_Shapes

	Boxes

	Octagonal_Shapes

	Pointset_Powersets

	Termination

	Watchdog

Classes
class	Doubly_Linked_Object
	A (base) class for doubly linked objects. More...

class	EList
	A simple kind of embedded list (i.e., a doubly linked objects where the links are embedded in the objects themselves). More...

class	EList_Iterator
	A class providing iterators for embedded lists. More...

struct	Indirect_Sort_Compare

struct	Indirect_Swapper

struct	Indirect_Swapper2

struct	Indirect_Unique_Compare

class	Ptr_Iterator
	A class to define STL const and non-const iterators from pointer types. More...

struct	Wrap_Dim_Translations

Typedefs
typedef std::vector< Wrap_Dim_Translations >	Wrap_Translations

Functions
unsigned int	first_one (unsigned int u)
	Assuming `u` is nonzero, returns the index of the first set bit in `u`. More...

unsigned int	first_one (unsigned long ul)
	Assuming `ul` is nonzero, returns the index of the first set bit in `ul`. More...

unsigned int	first_one (unsigned long long ull)
	Assuming `ull` is nonzero, returns the index of the first set bit in `ull`. More...

unsigned int	last_one (unsigned int u)
	Assuming `u` is nonzero, returns the index of the last set bit in `u`. More...

unsigned int	last_one (unsigned long ul)
	Assuming `ul` is nonzero, returns the index of the last set bit in `ul`. More...

unsigned int	last_one (unsigned long long ull)
	Assuming `ull` is nonzero, returns the index of the last set bit in `ull`. More...

dimension_type	num_constraints (const Constraint_System &cs)
	Helper returning number of constraints in system. More...

template<typename T >
bool	operator== (const EList_Iterator< T > &x, const EList_Iterator< T > &y)
	Returns `true` if and only if `x` and `y` are equal. More...

template<typename T >
bool	operator!= (const EList_Iterator< T > &x, const EList_Iterator< T > &y)
	Returns `true` if and only if `x` and `y` are different. More...

void	initialize_aux ()

void	finalize_aux ()

template<typename P , typename Q >
bool	operator== (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P , typename Q >
bool	operator!= (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P , typename Q >
bool	operator< (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P , typename Q >
bool	operator<= (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P , typename Q >
bool	operator> (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P , typename Q >
bool	operator>= (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P , typename Q >
Ptr_Iterator< P >::difference_type	operator- (const Ptr_Iterator< P > &x, const Ptr_Iterator< Q > &y)

template<typename P >
Ptr_Iterator< P >	operator+ (typename Ptr_Iterator< P >::difference_type m, const Ptr_Iterator< P > &y)

template<typename Sort_Comparer , typename Unique_Comparer , typename Swapper >
Sort_Comparer::size_type	indirect_sort_and_unique (typename Sort_Comparer::size_type num_elems, Sort_Comparer sort_cmp, Unique_Comparer unique_cmp, Swapper indirect_swap)

template<typename Iter >
Iter	swapping_unique (Iter first, Iter last)

template<typename PSET >
void	wrap_assign_ind (PSET &pointset, Variables_Set &vars, Wrap_Translations::const_iterator first, Wrap_Translations::const_iterator end, Bounded_Integer_Type_Width w, Coefficient_traits::const_reference min_value, Coefficient_traits::const_reference max_value, const Constraint_System &cs, Coefficient &tmp1, Coefficient &tmp2)

template<typename PSET >
void	wrap_assign_col (PSET &dest, const PSET &src, const Variables_Set &vars, Wrap_Translations::const_iterator first, Wrap_Translations::const_iterator end, Bounded_Integer_Type_Width w, Coefficient_traits::const_reference min_value, Coefficient_traits::const_reference max_value, const Constraint_System *cs_p, Coefficient &tmp)

template<typename PSET >
void	wrap_assign (PSET &pointset, const Variables_Set &vars, const Bounded_Integer_Type_Width w, const Bounded_Integer_Type_Representation r, const Bounded_Integer_Type_Overflow o, const Constraint_System cs_p, const unsigned complexity_threshold, const bool wrap_individually, const char class_name)

Detailed Description

Implementation related data and functions.

Typedef Documentation

typedef std::vector<Wrap_Dim_Translations> Parma_Polyhedra_Library::Implementation::Wrap_Translations

Definition at line 48 of file wrap_assign.hh.

Function Documentation

void Parma_Polyhedra_Library::Implementation::finalize_aux ( )

Definition at line 236 of file Init.cc.

Referenced by Parma_Polyhedra_Library::finalize().

                {
   PPL_ASSERT(Parma_Polyhedra_Library_initializer_p != 0);
   delete Parma_Polyhedra_Library_initializer_p;
   Parma_Polyhedra_Library_initializer_p = 0;
 }

unsigned int Parma_Polyhedra_Library::Implementation::first_one ( unsigned int u )

inline

Assuming u is nonzero, returns the index of the first set bit in u.

Definition at line 168 of file Bit_Row_inlines.hh.

References Parma_Polyhedra_Library::ctz().

Referenced by Parma_Polyhedra_Library::Bit_Row::first(), and Parma_Polyhedra_Library::Bit_Row::next().

                           {
   return ctz(u);
 }

unsigned int Parma_Polyhedra_Library::Implementation::first_one ( unsigned long ul )

inline

Assuming ul is nonzero, returns the index of the first set bit in ul.

Definition at line 177 of file Bit_Row_inlines.hh.

References Parma_Polyhedra_Library::ctz().

                             {
   return ctz(ul);
 }

unsigned int Parma_Polyhedra_Library::Implementation::first_one ( unsigned long long ull )

inline

Assuming ull is nonzero, returns the index of the first set bit in ull.

Definition at line 186 of file Bit_Row_inlines.hh.

References Parma_Polyhedra_Library::ctz().

                                   {
   return ctz(ull);
 }

template<typename Sort_Comparer , typename Unique_Comparer , typename Swapper >

Sort_Comparer::size_type Parma_Polyhedra_Library::Implementation::indirect_sort_and_unique	(	typename Sort_Comparer::size_type	num_elems,
		Sort_Comparer	sort_cmp,
		Unique_Comparer	unique_cmp,
		Swapper	indirect_swap
	)

Definition at line 106 of file swapping_sort_templates.hh.

Referenced by Parma_Polyhedra_Library::Linear_System< Row >::sort_and_remove_with_sat(), Parma_Polyhedra_Library::Bit_Matrix::sort_rows(), and Parma_Polyhedra_Library::Linear_System< Row >::sort_rows().

                                                 {
   typedef typename Sort_Comparer::size_type index_type;
   // `iv' is a vector of indices for the portion of rows to be sorted.
   PPL_ASSERT(num_elems >= 2);
   std::vector<index_type> iv;
   iv.reserve(num_elems);
   for (index_type i = 0, i_end = num_elems; i != i_end; ++i) {
     iv.push_back(i);
   }
 
   typedef typename std::vector<index_type>::iterator Iter;
   const Iter iv_begin = iv.begin();
   Iter iv_end = iv.end();
 
   // Sort `iv' by comparing the rows indexed by its elements.
   std::sort(iv_begin, iv_end, sort_cmp);
 
   // Swap the indexed rows according to `iv':
   // for each index `i', the element that should be placed in
   // position dst = i is the one placed in position src = iv[i].
   for (index_type i = num_elems; i-- > 0; ) {
     if (i != iv[i]) {
       index_type dst = i;
       index_type src = iv[i];
       do {
         indirect_swap(src, dst);
         iv[dst] = dst;
         dst = src;
         src = iv[dst];
       } while (i != src);
       iv[dst] = dst;
     }
   }
 
   // Restore `iv' indices to 0 .. num_elems-1 for the call to unique.
   for (index_type i = num_elems; i-- > 0; ) {
     iv[i] = i;
   }
 
   // Unique `iv' by comparing the rows indexed by its elements.
   iv_end = std::unique(iv_begin, iv_end, unique_cmp);
 
   const index_type num_sorted = static_cast<index_type>(iv_end - iv_begin);
   const index_type num_duplicates = num_elems - num_sorted;
   if (num_duplicates == 0) {
     return 0;
   }
 
   // There were duplicates: swap the rows according to `iv'.
   index_type dst = 0;
   while (dst < num_sorted && dst == iv[dst]) {
     ++dst;
   }
   if (dst == num_sorted) {
     return num_duplicates;
   }
   do {
     const index_type src = iv[dst];
     indirect_swap(src, dst);
     ++dst;
   }
   while (dst < num_sorted);
   return num_duplicates;
 }

void Parma_Polyhedra_Library::Implementation::initialize_aux ( )

Definition at line 229 of file Init.cc.

Referenced by Parma_Polyhedra_Library::initialize().

                  {
   if (Parma_Polyhedra_Library_initializer_p == 0) {
     Parma_Polyhedra_Library_initializer_p = new Init();
   }
 }

unsigned int Parma_Polyhedra_Library::Implementation::last_one ( unsigned int u )

inline

Assuming u is nonzero, returns the index of the last set bit in u.

Definition at line 194 of file Bit_Row_inlines.hh.

References Parma_Polyhedra_Library::clz(), and sizeof_to_bits.

Referenced by Parma_Polyhedra_Library::Bit_Row::last(), and Parma_Polyhedra_Library::Bit_Row::prev().

                          {
   return static_cast<unsigned int>(sizeof_to_bits(sizeof(u)))
     - 1U - clz(u);
 }

unsigned int Parma_Polyhedra_Library::Implementation::last_one ( unsigned long ul )

inline

Assuming ul is nonzero, returns the index of the last set bit in ul.

Definition at line 204 of file Bit_Row_inlines.hh.

References Parma_Polyhedra_Library::clz(), and sizeof_to_bits.

                            {
   return static_cast<unsigned int>(sizeof_to_bits(sizeof(ul)))
     - 1U - clz(ul);
 }

unsigned int Parma_Polyhedra_Library::Implementation::last_one ( unsigned long long ull )

inline

Assuming ull is nonzero, returns the index of the last set bit in ull.

Definition at line 214 of file Bit_Row_inlines.hh.

References Parma_Polyhedra_Library::clz(), and sizeof_to_bits.

                                  {
   return static_cast<unsigned int>(sizeof_to_bits(sizeof(ull)))
     - 1U - clz(ull);
 }

dimension_type Parma_Polyhedra_Library::Implementation::num_constraints ( const Constraint_System & cs )

template<typename P , typename Q >

bool Parma_Polyhedra_Library::Implementation::operator!=	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 141 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                                {
   return x.base() != y.base();
 }

template<typename T >

bool Parma_Polyhedra_Library::Implementation::operator!=	(	const EList_Iterator< T > &	x,
		const EList_Iterator< T > &	y
	)

inline

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

Definition at line 101 of file EList_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::EList_Iterator< T >::ptr.

                                                                    {
   return x.ptr != y.ptr;
 }

template<typename P >

Ptr_Iterator< P > Parma_Polyhedra_Library::Implementation::operator+	(	typename Ptr_Iterator< P >::difference_type	m,
		const Ptr_Iterator< P > &	y
	)

inline

Definition at line 177 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                     {
   return Ptr_Iterator<P>(m + y.base());
 }

template<typename P , typename Q >

Ptr_Iterator< P >::difference_type Parma_Polyhedra_Library::Implementation::operator-	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 171 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                               {
   return x.base() - y.base();
 }

template<typename P , typename Q >

bool Parma_Polyhedra_Library::Implementation::operator<	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 147 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                               {
   return x.base() < y.base();
 }

template<typename P , typename Q >

bool Parma_Polyhedra_Library::Implementation::operator<=	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 153 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                                {
   return x.base() <= y.base();
 }

template<typename P , typename Q >

bool Parma_Polyhedra_Library::Implementation::operator==	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 135 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                                {
   return x.base() == y.base();
 }

template<typename T >

bool Parma_Polyhedra_Library::Implementation::operator==	(	const EList_Iterator< T > &	x,
		const EList_Iterator< T > &	y
	)

inline

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

Definition at line 95 of file EList_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::EList_Iterator< T >::ptr.

                                                                    {
   return x.ptr == y.ptr;
 }

template<typename P , typename Q >

bool Parma_Polyhedra_Library::Implementation::operator>	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 159 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                               {
   return x.base() > y.base();
 }

template<typename P , typename Q >

bool Parma_Polyhedra_Library::Implementation::operator>=	(	const Ptr_Iterator< P > &	x,
		const Ptr_Iterator< Q > &	y
	)

inline

Definition at line 165 of file Ptr_Iterator_inlines.hh.

References Parma_Polyhedra_Library::Implementation::Ptr_Iterator::base().

                                                                {
   return x.base() >= y.base();
 }

template<typename Iter >

Iter Parma_Polyhedra_Library::Implementation::swapping_unique	(	Iter	first,
		Iter	last
	)

Definition at line 176 of file swapping_sort_templates.hh.

                                        {
   return swapping_unique(first, last, std::iter_swap<Iter, Iter>);
 }

template<typename PSET >

void Parma_Polyhedra_Library::Implementation::wrap_assign	(	PSET &	pointset,
		const Variables_Set &	vars,
		const Bounded_Integer_Type_Width	w,
		const Bounded_Integer_Type_Representation	r,
		const Bounded_Integer_Type_Overflow	o,
		const Constraint_System *	cs_p,
		const unsigned	complexity_threshold,
		const bool	wrap_individually,
		const char *	class_name
	)

Definition at line 152 of file wrap_assign.hh.

Referenced by Parma_Polyhedra_Library::Box< ITV >::wrap_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::wrap_assign(), Parma_Polyhedra_Library::BD_Shape< T >::wrap_assign(), and Parma_Polyhedra_Library::Polyhedron::wrap_assign().

                                     {
   // We must have cs_p->space_dimension() <= vars.space_dimension()
   //         and  vars.space_dimension() <= pointset.space_dimension().
 
   // Dimension-compatibility check of `*cs_p', if any.
   if (cs_p != 0) {
     const dimension_type vars_space_dim = vars.space_dimension();
     if (cs_p->space_dimension() > vars_space_dim) {
       std::ostringstream s;
       s << "PPL::" << class_name << "::wrap_assign(..., cs_p, ...):"
         << std::endl
         << "vars.space_dimension() == " << vars_space_dim
         << ", cs_p->space_dimension() == " << cs_p->space_dimension() << ".";
       throw std::invalid_argument(s.str());
     }
 
 #ifndef NDEBUG
     // Check that all variables upon which `*cs_p' depends are in `vars'.
     // An assertion is violated otherwise.
     const Constraint_System cs = *cs_p;
     const dimension_type cs_space_dim = cs.space_dimension();
     Variables_Set::const_iterator vars_end = vars.end();
     for (Constraint_System::const_iterator i = cs.begin(),
            cs_end = cs.end(); i != cs_end; ++i) {
       const Constraint& c = *i;
       for (dimension_type d = cs_space_dim; d-- > 0; ) {
         PPL_ASSERT(c.coefficient(Variable(d)) == 0
                    || vars.find(d) != vars_end);
       }
     }
 #endif
   }
 
   // Wrapping no variable only requires refining with *cs_p, if any.
   if (vars.empty()) {
     if (cs_p != 0) {
       pointset.refine_with_constraints(*cs_p);
     }
     return;
   }
 
   // Dimension-compatibility check of `vars'.
   const dimension_type space_dim = pointset.space_dimension();
   if (vars.space_dimension() > space_dim) {
     std::ostringstream s;
     s << "PPL::" << class_name << "::wrap_assign(vs, ...):" << std::endl
       << "this->space_dimension() == " << space_dim
       << ", required space dimension == " << vars.space_dimension() << ".";
     throw std::invalid_argument(s.str());
   }
 
   // Wrapping an empty polyhedron is a no-op.
   if (pointset.is_empty()) {
     return;
   }
   // Set `min_value' and `max_value' to the minimum and maximum values
   // a variable of width `w' and signedness `s' can take.
   PPL_DIRTY_TEMP_COEFFICIENT(min_value);
   PPL_DIRTY_TEMP_COEFFICIENT(max_value);
   if (r == UNSIGNED) {
     min_value = 0;
     mul_2exp_assign(max_value, Coefficient_one(), w);
     --max_value;
   }
   else {
     PPL_ASSERT(r == SIGNED_2_COMPLEMENT);
     mul_2exp_assign(max_value, Coefficient_one(), w-1);
     neg_assign(min_value, max_value);
     --max_value;
   }
 
   // If we are wrapping variables collectively, the ranges for the
   // required translations are saved in `translations' instead of being
   // immediately applied.
   Wrap_Translations translations;
 
   // Dimensions subject to translation are added to this set if we are
   // wrapping collectively or if `cs_p' is non null.
   Variables_Set dimensions_to_be_translated;
 
   // This will contain a lower bound to the number of abstractions
   // to be joined in order to obtain the collective wrapping result.
   // As soon as this exceeds `complexity_threshold', counting will be
   // interrupted and the full range will be the result of wrapping
   // any dimension that is not fully contained in quadrant 0.
   unsigned collective_wrap_complexity = 1;
 
   // This flag signals that the maximum complexity for collective
   // wrapping as been exceeded.
   bool collective_wrap_too_complex = false;
 
   if (!wrap_individually) {
     translations.reserve(space_dim);
   }
 
   // We use `full_range_bounds' to delay conversions whenever
   // this delay does not negatively affect precision.
   Constraint_System full_range_bounds;
 
   PPL_DIRTY_TEMP_COEFFICIENT(l_n);
   PPL_DIRTY_TEMP_COEFFICIENT(l_d);
   PPL_DIRTY_TEMP_COEFFICIENT(u_n);
   PPL_DIRTY_TEMP_COEFFICIENT(u_d);
 
   for (Variables_Set::const_iterator i = vars.begin(),
          vars_end = vars.end(); i != vars_end; ++i) {
 
     const Variable x(*i);
 
     bool extremum;
 
     if (!pointset.minimize(x, l_n, l_d, extremum)) {
     set_full_range:
       pointset.unconstrain(x);
       full_range_bounds.insert(min_value <= x);
       full_range_bounds.insert(x <= max_value);
       continue;
     }
 
     if (!pointset.maximize(x, u_n, u_d, extremum)) {
       goto set_full_range;
     }
 
     div_assign_r(l_n, l_n, l_d, ROUND_DOWN);
     div_assign_r(u_n, u_n, u_d, ROUND_DOWN);
     l_n -= min_value;
     u_n -= min_value;
     div_2exp_assign_r(l_n, l_n, w, ROUND_DOWN);
     div_2exp_assign_r(u_n, u_n, w, ROUND_DOWN);
     Coefficient& first_quadrant = l_n;
     const Coefficient& last_quadrant = u_n;
 
     // Special case: this variable does not need wrapping.
     if (first_quadrant == 0 && last_quadrant == 0) {
       continue;
     }
 
     // If overflow is impossible, try not to add useless constraints.
     if (o == OVERFLOW_IMPOSSIBLE) {
       if (first_quadrant < 0) {
         full_range_bounds.insert(min_value <= x);
       }
       if (last_quadrant > 0) {
         full_range_bounds.insert(x <= max_value);
       }
       continue;
     }
 
     if (o == OVERFLOW_UNDEFINED || collective_wrap_too_complex) {
       goto set_full_range;
     }
 
     Coefficient& quadrants = u_d;
     quadrants = last_quadrant - first_quadrant + 1;
 
     PPL_UNINITIALIZED(unsigned, extension);
     Result res = assign_r(extension, quadrants, ROUND_IGNORE);
     if (result_overflow(res) != 0 || extension > complexity_threshold) {
       goto set_full_range;
     }
 
     if (!wrap_individually && !collective_wrap_too_complex) {
       res = mul_assign_r(collective_wrap_complexity,
                          collective_wrap_complexity, extension, ROUND_IGNORE);
       if (result_overflow(res) != 0
           || collective_wrap_complexity > complexity_threshold) {
         collective_wrap_too_complex = true;
       }
       if (collective_wrap_too_complex) {
         // Set all the dimensions in `translations' to full range.
         for (Wrap_Translations::const_iterator j = translations.begin(),
                translations_end = translations.end();
              j != translations_end;
              ++j) {
           const Variable y(j->var);
           pointset.unconstrain(y);
           full_range_bounds.insert(min_value <= y);
           full_range_bounds.insert(y <= max_value);
         }
       }
     }
 
     if (wrap_individually && cs_p == 0) {
       Coefficient& quadrant = first_quadrant;
       // Temporary variable holding the shifts to be applied in order
       // to implement the translations.
       Coefficient& shift = l_d;
       PSET hull(space_dim, EMPTY);
       for ( ; quadrant <= last_quadrant; ++quadrant) {
         PSET p(pointset);
         if (quadrant != 0) {
           mul_2exp_assign(shift, quadrant, w);
           p.affine_image(x, x - shift, 1);
         }
         p.refine_with_constraint(min_value <= x);
         p.refine_with_constraint(x <= max_value);
         hull.upper_bound_assign(p);
       }
       pointset.m_swap(hull);
     }
     else if (wrap_individually || !collective_wrap_too_complex) {
       PPL_ASSERT(!wrap_individually || cs_p != 0);
       dimensions_to_be_translated.insert(x);
       translations
         .push_back(Wrap_Dim_Translations(x, first_quadrant, last_quadrant));
     }
   }
 
   if (!translations.empty()) {
     if (wrap_individually) {
       PPL_ASSERT(cs_p != 0);
       wrap_assign_ind(pointset, dimensions_to_be_translated,
                       translations.begin(), translations.end(),
                       w, min_value, max_value, *cs_p, l_n, l_d);
     }
     else {
       PSET hull(space_dim, EMPTY);
       wrap_assign_col(hull, pointset, dimensions_to_be_translated,
                       translations.begin(), translations.end(),
                       w, min_value, max_value, cs_p, l_n);
       pointset.m_swap(hull);
     }
   }
 
   if (cs_p != 0) {
     pointset.refine_with_constraints(*cs_p);
   }
   pointset.refine_with_constraints(full_range_bounds);
 }

template<typename PSET >

void Parma_Polyhedra_Library::Implementation::wrap_assign_col	(	PSET &	dest,
		const PSET &	src,
		const Variables_Set &	vars,
		Wrap_Translations::const_iterator	first,
		Wrap_Translations::const_iterator	end,
		Bounded_Integer_Type_Width	w,
		Coefficient_traits::const_reference	min_value,
		Coefficient_traits::const_reference	max_value,
		const Constraint_System *	cs_p,
		Coefficient &	tmp
	)

Definition at line 104 of file wrap_assign.hh.

References Parma_Polyhedra_Library::Implementation::Wrap_Dim_Translations::first_quadrant, Parma_Polyhedra_Library::Implementation::Wrap_Dim_Translations::last_quadrant, Parma_Polyhedra_Library::mul_2exp_assign(), PPL_DIRTY_TEMP_COEFFICIENT, and Parma_Polyhedra_Library::Implementation::Wrap_Dim_Translations::var.

Referenced by wrap_assign().

                                   {
   if (first == end) {
     PSET p(src);
     if (cs_p != 0) {
       p.refine_with_constraints(*cs_p);
     }
     for (Variables_Set::const_iterator i = vars.begin(),
            vars_end = vars.end(); i != vars_end; ++i) {
       const Variable x(*i);
       p.refine_with_constraint(min_value <= x);
       p.refine_with_constraint(x <= max_value);
     }
     dest.upper_bound_assign(p);
   }
   else {
     const Wrap_Dim_Translations& wrap_dim_translations = *first;
     const Variable x(wrap_dim_translations.var);
     const Coefficient& first_quadrant = wrap_dim_translations.first_quadrant;
     const Coefficient& last_quadrant = wrap_dim_translations.last_quadrant;
     Coefficient& shift = tmp;
     PPL_DIRTY_TEMP_COEFFICIENT(quadrant);
     for (quadrant = first_quadrant; quadrant <= last_quadrant; ++quadrant) {
       if (quadrant != 0) {
         mul_2exp_assign(shift, quadrant, w);
         PSET p(src);
         p.affine_image(x, x - shift, 1);
         wrap_assign_col(dest, p, vars, first+1, end, w, min_value, max_value,
                         cs_p, tmp);
       }
       else {
         wrap_assign_col(dest, src, vars, first+1, end, w, min_value, max_value,
                         cs_p, tmp);
       }
     }
   }
 }

template<typename PSET >

void Parma_Polyhedra_Library::Implementation::wrap_assign_ind	(	PSET &	pointset,
		Variables_Set &	vars,
		Wrap_Translations::const_iterator	first,
		Wrap_Translations::const_iterator	end,
		Bounded_Integer_Type_Width	w,
		Coefficient_traits::const_reference	min_value,
		Coefficient_traits::const_reference	max_value,
		const Constraint_System &	cs,
		Coefficient &	tmp1,
		Coefficient &	tmp2
	)

Definition at line 52 of file wrap_assign.hh.

References Parma_Polyhedra_Library::Constraint_System::begin(), Parma_Polyhedra_Library::EMPTY, Parma_Polyhedra_Library::Constraint_System::end(), Parma_Polyhedra_Library::Implementation::Wrap_Dim_Translations::first_quadrant, Parma_Polyhedra_Library::Variable::id(), Parma_Polyhedra_Library::Implementation::Wrap_Dim_Translations::last_quadrant, Parma_Polyhedra_Library::mul_2exp_assign(), and Parma_Polyhedra_Library::Implementation::Wrap_Dim_Translations::var.

Referenced by wrap_assign().

                                    {
   const dimension_type space_dim = pointset.space_dimension();
   for (Wrap_Translations::const_iterator i = first; i != end; ++i) {
     const Wrap_Dim_Translations& wrap_dim_translations = *i;
     const Variable x(wrap_dim_translations.var);
     const Coefficient& first_quadrant = wrap_dim_translations.first_quadrant;
     const Coefficient& last_quadrant = wrap_dim_translations.last_quadrant;
     Coefficient& quadrant = tmp1;
     Coefficient& shift = tmp2;
     PSET hull(space_dim, EMPTY);
     for (quadrant = first_quadrant; quadrant <= last_quadrant; ++quadrant) {
       PSET p(pointset);
       if (quadrant != 0) {
         mul_2exp_assign(shift, quadrant, w);
         p.affine_image(x, x - shift, 1);
       }
       // `x' has just been wrapped.
       vars.erase(x.id());
 
       // Refine `p' with all the constraints in `cs' not depending
       // on variables in `vars'.
       if (vars.empty()) {
         p.refine_with_constraints(cs);
       }
       else {
         for (Constraint_System::const_iterator j = cs.begin(),
                cs_end = cs.end(); j != cs_end; ++j) {
           if (j->expression().all_zeroes(vars)) {
             // `*j' does not depend on variables in `vars'.
             p.refine_with_constraint(*j);
           }
         }
       }
       p.refine_with_constraint(min_value <= x);
       p.refine_with_constraint(x <= max_value);
       hull.upper_bound_assign(p);
     }
     pointset.m_swap(hull);
   }
 }

Namespaces

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

Function Documentation