A generic, not necessarily closed, possibly restricted interval. More...

#include <Interval_defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::Interval< Boundary, Info >:

Collaboration diagram for Parma_Polyhedra_Library::Interval< Boundary, Info >:

Public Types
typedef Boundary	boundary_type

typedef Info	info_type

typedef Interval_NS::Property	Property

Public Member Functions
template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, Interval & >::type	operator= (const T &x)

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, Interval & >::type	operator+= (const T &x)

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, Interval & >::type	operator-= (const T &x)

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, Interval & >::type	operator*= (const T &x)

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, Interval & >::type	operator/= (const T &x)

void	m_swap (Interval &y)
	Swaps `*this` with `y`. More...

Info &	info ()

const Info &	info () const

Boundary &	lower ()

const Boundary &	lower () const

Boundary &	upper ()

const Boundary &	upper () const

I_Constraint< boundary_type >	lower_constraint () const

I_Constraint< boundary_type >	upper_constraint () const

bool	is_empty () const

bool	check_empty (I_Result r) const

bool	is_singleton () const

bool	lower_is_open () const

bool	upper_is_open () const

bool	lower_is_boundary_infinity () const

bool	upper_is_boundary_infinity () const

bool	lower_is_domain_inf () const

bool	upper_is_domain_sup () const

bool	is_bounded () const

bool	is_universe () const

I_Result	lower_extend ()

template<typename C >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C >::value, I_Result >::type	lower_extend (const C &c)

I_Result	upper_extend ()

template<typename C >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C >::value, I_Result >::type	upper_extend (const C &c)

I_Result	build ()

template<typename C >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C >::value, I_Result >::type	build (const C &c)

template<typename C1 , typename C2 >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C1 >::value &&Is_Same_Or_Derived< I_Constraint_Base, C2 >::value, I_Result >::type	build (const C1 &c1, const C2 &c2)

template<typename C >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C >::value, I_Result >::type	add_constraint (const C &c)

I_Result	assign (Degenerate_Element e)

template<typename From >
Enable_If< Is_Special< From >::value, I_Result >::type	assign (const From &)

I_Result	set_infinities ()

bool	is_topologically_closed () const

void	topological_closure_assign ()
	Assigns to `*this` its topological closure. More...

void	remove_inf ()

void	remove_sup ()

int	infinity_sign () const

bool	contains_integer_point () const

void	drop_some_non_integer_points ()

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	wrap_assign (Bounded_Integer_Type_Width w, Bounded_Integer_Type_Representation r, const From &refinement)

memory_size_type	total_memory_in_bytes () const
	Returns the total size in bytes of the memory occupied by `*this`. More...

memory_size_type	external_memory_in_bytes () const
	Returns the size in bytes of the memory managed by `*this`. More...

void	ascii_dump (std::ostream &s) const

bool	ascii_load (std::istream &s)

bool	OK () const

	Interval ()

template<typename T >
	Interval (const T &x)

	Interval (const char *s)
	Builds the smallest interval containing the number whose textual representation is contained in `s`. More...

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, bool >::type	contains (const T &y) const

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, bool >::type	strictly_contains (const T &y) const

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, bool >::type	is_disjoint_from (const T &y) const

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	assign (const From &x)

template<typename Type >
Enable_If< Is_Singleton< Type >::value\|\|Is_Interval< Type >::value, bool >::type	can_be_exactly_joined_to (const Type &x) const

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	join_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	join_assign (const From1 &x, const From2 &y)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	intersect_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	intersect_assign (const From1 &x, const From2 &y)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	difference_assign (const From &x)
	Assigns to `this` the smallest interval containing the set-theoretic difference of `this` and `x`. More...

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	difference_assign (const From1 &x, const From2 &y)
	Assigns to `*this` the smallest interval containing the set-theoretic difference of `x` and `y`. More...

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	lower_approximation_difference_assign (const From &x)
	Assigns to `this` the largest interval contained in the set-theoretic difference of `this` and `x`. More...

template<typename From >
Enable_If< Is_Interval< From >::value, bool >::type	simplify_using_context_assign (const From &y)
	Assigns to `this` a meet-preserving simplification of `this` with respect to `y`. More...

template<typename From >
Enable_If< Is_Interval< From >::value, void >::type	empty_intersection_assign (const From &y)
	Assigns to `*this` an interval having empty intersection with `y`. The assigned interval should be as large as possible. More...

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	refine_existential (Relation_Symbol rel, const From &x)
	Refines `to` according to the existential relation `rel` with `x`. More...

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	refine_universal (Relation_Symbol rel, const From &x)
	Refines `to` so that it satisfies the universal relation `rel` with `x`. More...

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	neg_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	add_assign (const From1 &x, const From2 &y)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	sub_assign (const From1 &x, const From2 &y)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	mul_assign (const From1 &x, const From2 &y)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	div_assign (const From1 &x, const From2 &y)

template<typename From , typename Iterator >
Enable_If< Is_Interval< From >::value, void >::type	CC76_widening_assign (const From &y, Iterator first, Iterator last)

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, bool >::type	contains (const T &y) const

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, bool >::type	strictly_contains (const T &y) const

template<typename T >
Enable_If< Is_Singleton< T >::value\|\|Is_Interval< T >::value, bool >::type	is_disjoint_from (const T &y) const

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	assign (const From &x)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	join_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	join_assign (const From1 &x, const From2 &y)

template<typename Type >
Enable_If< Is_Singleton< Type >::value\|\|Is_Interval< Type >::value, bool >::type	can_be_exactly_joined_to (const Type &x) const

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	intersect_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	intersect_assign (const From1 &x, const From2 &y)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	difference_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	difference_assign (const From1 &x, const From2 &y)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	refine_existential (Relation_Symbol rel, const From &x)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	refine_universal (Relation_Symbol rel, const From &x)

template<typename From >
Enable_If< Is_Singleton< From >::value\|\|Is_Interval< From >::value, I_Result >::type	neg_assign (const From &x)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	add_assign (const From1 &x, const From2 &y)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	sub_assign (const From1 &x, const From2 &y)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	mul_assign (const From1 &x, const From2 &y)

template<typename From1 , typename From2 >
Enable_If<((Is_Singleton< From1 >::value\|\|Is_Interval< From1 >::value)&&(Is_Singleton< From2 >::value\|\|Is_Interval< From2 >::value)), I_Result >::type	div_assign (const From1 &x, const From2 &y)

template<typename C >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C >::value, I_Result >::type	lower_extend (const C &c)

template<typename C >
Enable_If< Is_Same_Or_Derived< I_Constraint_Base, C >::value, I_Result >::type	upper_extend (const C &c)

template<typename From , typename Iterator >
Enable_If< Is_Interval< From >::value, void >::type	CC76_widening_assign (const From &y, Iterator first, Iterator last)

template<typename From >
Enable_If< Is_Interval< From >::value, bool >::type	simplify_using_context_assign (const From &y)

template<typename From >
Enable_If< Is_Interval< From >::value, void >::type	empty_intersection_assign (const From &)

Static Public Member Functions
static bool	is_always_topologically_closed ()

Private Member Functions
	PPL_COMPILE_TIME_CHECK (!Info::store_special\|\|!std::numeric_limits< Boundary >::has_infinity,"store_special is meaningless"" when boundary type may contains infinity")

Info &	w_info () const

Private Attributes
Boundary	lower_

Boundary	upper_

Related Functions
(Note that these are not member functions.)
template<typename Boundary , typename Info >
void	swap (Interval< Boundary, Info > &x, Interval< Boundary, Info > &y)
	Swaps `x` with `y`. More...

template<typename Boundary , typename Info >
void	swap (Interval< Boundary, Info > &x, Interval< Boundary, Info > &y)

Detailed Description

template<typename Boundary, typename Info>
class Parma_Polyhedra_Library::Interval< Boundary, Info >

A generic, not necessarily closed, possibly restricted interval.

The class template type parameter Boundary represents the type of the interval boundaries, and can be chosen, among other possibilities, within one of the following number families:

a bounded precision native integer type (that is, from signed char to long long and from int8_t to int64_t);
a bounded precision floating point type (float, double or long double);
an unbounded integer or rational type, as provided by the C++ interface of GMP (mpz_class or mpq_class).

The class template type parameter Info allows to control a number of features of the class, among which:

the ability to support open as well as closed boundaries;
the ability to represent empty intervals in addition to nonempty ones;
the ability to represent intervals of extended number families that contain positive and negative infinities;

Definition at line 81 of file Interval_defs.hh.

Member Typedef Documentation

template<typename Boundary, typename Info>

typedef Boundary Parma_Polyhedra_Library::Interval< Boundary, Info >::boundary_type

Definition at line 92 of file Interval_defs.hh.

template<typename Boundary, typename Info>

typedef Info Parma_Polyhedra_Library::Interval< Boundary, Info >::info_type

Definition at line 93 of file Interval_defs.hh.

template<typename Boundary, typename Info>

typedef Interval_NS::Property Parma_Polyhedra_Library::Interval< Boundary, Info >::Property

Definition at line 95 of file Interval_defs.hh.

Constructor & Destructor Documentation

template<typename Boundary, typename Info>

Parma_Polyhedra_Library::Interval< Boundary, Info >::Interval ( )

inline

Definition at line 585 of file Interval_defs.hh.

585 {

586 }

template<typename Boundary, typename Info>

template<typename T >

Parma_Polyhedra_Library::Interval< Boundary, Info >::Interval ( const T & x )

inlineexplicit

Definition at line 589 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::assign().

                                 {
     assign(x);
   }

template<typename Boundary , typename Info >

Parma_Polyhedra_Library::Interval< Boundary, Info >::Interval ( const char * s )

explicit

Builds the smallest interval containing the number whose textual representation is contained in s.

Definition at line 143 of file Interval_templates.hh.

                                                 {
   // Get the lower bound.
   Boundary lower_bound;
   Result lower_r = assign_r(lower_bound, s, ROUND_DOWN);
   if (lower_r == V_CVT_STR_UNK || lower_r == V_NAN) {
     throw std::invalid_argument("PPL::Interval(const char* s)"
                                 " with s invalid");
   }
   lower_r = result_relation_class(lower_r);
 
   // Get the upper bound.
   Boundary upper_bound;
   Result upper_r = assign_r(upper_bound, s, ROUND_UP);
   PPL_ASSERT(upper_r != V_CVT_STR_UNK && upper_r != V_NAN);
   upper_r = result_relation_class(upper_r);
 
   // Build the interval.
   bool lower_open = false;
   bool upper_open = false;
   bool lower_boundary_infinity = false;
   bool upper_boundary_infinity = false;
   switch (lower_r) {
   case V_EQ: // Fall through.
   case V_GE:
     break;
   case V_GT:
     lower_open = true;
     break;
   case V_GT_MINUS_INFINITY:
     lower_open = true;
     // Fall through.
   case V_EQ_MINUS_INFINITY:
     lower_boundary_infinity = true;
     break;
   case V_EQ_PLUS_INFINITY: // Fall through.
   case V_LT_PLUS_INFINITY:
     if (upper_r == V_EQ_PLUS_INFINITY || upper_r == V_LT_PLUS_INFINITY) {
       assign(UNIVERSE);
     }
     else {
       assign(EMPTY);
     }
     break;
   default:
     PPL_UNREACHABLE;
     break;
   }
   switch (upper_r) {
   case V_EQ: // Fall through.
   case V_LE:
     break;
   case V_LT:
     upper_open = true;
     break;
   case V_EQ_MINUS_INFINITY: // Fall through.
   case V_GT_MINUS_INFINITY:
     if (lower_r == V_EQ_MINUS_INFINITY || lower_r == V_GT_MINUS_INFINITY) {
       assign(UNIVERSE);
     }
     else {
       assign(EMPTY);
     }
     break;
   case V_LT_PLUS_INFINITY:
     upper_open = true;
     // Fall through.
   case V_EQ_PLUS_INFINITY:
     upper_boundary_infinity = true;
     break;
   default:
     PPL_UNREACHABLE;
     break;
   }
 
   if (!lower_boundary_infinity
       && !upper_boundary_infinity
       && (lower_bound > upper_bound
           || (lower_open && lower_bound == upper_bound))) {
     assign(EMPTY);
   }
   else {
     if (lower_boundary_infinity) {
       set_minus_infinity(LOWER, lower(), info(), lower_open);
     }
     else {
       Boundary_NS::assign(LOWER, lower(), info(),
                           LOWER, lower_bound, SCALAR_INFO, lower_open);
     }
     if (upper_boundary_infinity) {
       set_plus_infinity(UPPER, upper(), info(), upper_open);
     }
     else {
       Boundary_NS::assign(UPPER, upper(), info(),
                           UPPER, upper_bound, SCALAR_INFO, upper_open);
     }
   }
 }

Member Function Documentation

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

Definition at line 618 of file Interval_inlines.hh.

                                                                          {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(x) || check_empty_arg(y)) {
     return assign(EMPTY);
   }
   int inf_sign = Parma_Polyhedra_Library::infinity_sign(x);
   if (inf_sign != 0) {
     if (Parma_Polyhedra_Library::infinity_sign(y) == -inf_sign) {
       return assign(EMPTY);
     }
   }
   else {
     inf_sign = Parma_Polyhedra_Library::infinity_sign(y);
   }
   if (inf_sign < 0) {
     return assign(MINUS_INFINITY);
   }
   else if (inf_sign > 0) {
     return assign(PLUS_INFINITY);
   }
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   Result rl = Boundary_NS::add_assign(LOWER, lower(), to_info,
                                       LOWER, f_lower(x), f_info(x),
                                       LOWER, f_lower(y), f_info(y));
   Result ru = Boundary_NS::add_assign(UPPER, upper(), to_info,
                                       UPPER, f_upper(x), f_info(x),
                                       UPPER, f_upper(y), f_info(y));
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign	(	const From1 &	x,
		const From2 &	y
	)

Referenced by Parma_Polyhedra_Library::operator+().

template<typename Boundary, typename Info>

template<typename C >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::add_constraint ( const C & c )

inline

Definition at line 302 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::build().

                              {
     Interval x;
     x.build(c);
     return intersect_assign(x);
   }

template<typename Boundary , typename Info >

void Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_dump ( std::ostream & s ) const

inline

Definition at line 1113 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::ascii_dump().

                                                         {
   using Parma_Polyhedra_Library::ascii_dump;
   s << "info ";
   info().ascii_dump(s);
   s << " lower ";
   ascii_dump(s, lower());
   s << " upper ";
   ascii_dump(s, upper());
   s << '\n';
 }

template<typename Boundary , typename Info >

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_load ( std::istream & s )

inline

Definition at line 1126 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::ascii_load().

                                                   {
   using Parma_Polyhedra_Library::ascii_load;
   std::string str;
   if (!(s >> str) || str != "info") {
     return false;
   }
   if (!info().ascii_load(s)) {
     return false;
   }
   if (!(s >> str) || str != "lower") {
     return false;
   }
   if (!ascii_load(s, lower())) {
     return false;
   }
   if (!(s >> str) || str != "upper") {
     return false;
   }
   if (!ascii_load(s, upper())) {
     return false;
   }
   PPL_ASSERT(OK());
   return true;
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::assign ( const From & x )

inline

Definition at line 243 of file Interval_inlines.hh.

                                                     {
   PPL_ASSERT(f_OK(x));
   if (check_empty_arg(x)) {
     return assign(EMPTY);
   }
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   const Result rl = Boundary_NS::assign(LOWER, lower(), to_info,
                                         LOWER, f_lower(x), f_info(x));
   const Result ru = Boundary_NS::assign(UPPER, upper(), to_info,
                                         UPPER, f_upper(x), f_info(x));
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

I_Result Parma_Polyhedra_Library::Interval< Boundary, Info >::assign ( Degenerate_Element e )

inline

Definition at line 308 of file Interval_defs.hh.

References Parma_Polyhedra_Library::EMPTY, Parma_Polyhedra_Library::I_EMPTY, Parma_Polyhedra_Library::I_EXACT, Parma_Polyhedra_Library::I_UNIVERSE, Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::set_unbounded(), Parma_Polyhedra_Library::UNIVERSE, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

Referenced by Parma_Polyhedra_Library::operator>>().

                                         {
     I_Result r;
     info().clear();
     switch (e) {
     case EMPTY:
       lower_ = 1;
       upper_ = 0;
       r = I_EMPTY | I_EXACT;
       break;
     case UNIVERSE:
       set_unbounded(LOWER, lower(), info());
       set_unbounded(UPPER, upper(), info());
       r = I_UNIVERSE | I_EXACT;
       break;
     default:
       PPL_UNREACHABLE;
       r = I_EMPTY;
       break;
     }
     PPL_ASSERT(OK());
     return r;
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Special<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::assign ( const From & )

inline

Definition at line 333 of file Interval_defs.hh.

References Parma_Polyhedra_Library::combine(), Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::set_minus_infinity(), Parma_Polyhedra_Library::Boundary_NS::set_plus_infinity(), Parma_Polyhedra_Library::Boundary_NS::UPPER, Parma_Polyhedra_Library::V_NAN, Parma_Polyhedra_Library::VC_MINUS_INFINITY, and Parma_Polyhedra_Library::VC_PLUS_INFINITY.

                       {
     info().clear();
     Result rl;
     Result ru;
     switch (From::vclass) {
     case VC_MINUS_INFINITY:
       rl = Boundary_NS::set_minus_infinity(LOWER, lower(), info());
       ru = Boundary_NS::set_minus_infinity(UPPER, upper(), info());
       break;
     case VC_PLUS_INFINITY:
       rl = Boundary_NS::set_plus_infinity(LOWER, lower(), info());
       ru = Boundary_NS::set_plus_infinity(UPPER, upper(), info());
       break;
     default:
       PPL_UNREACHABLE;
       rl = V_NAN;
       ru = V_NAN;
       break;
     }
     PPL_ASSERT(OK());
     return combine(rl, ru);
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::assign ( const From & x )

template<typename Boundary, typename Info>

I_Result Parma_Polyhedra_Library::Interval< Boundary, Info >::build ( )

inline

Definition at line 246 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::assign(), and Parma_Polyhedra_Library::UNIVERSE.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_constraint().

                    {
     return assign(UNIVERSE);
   }

template<typename Boundary, typename Info>

template<typename C >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::build ( const C & c )

inline

Definition at line 252 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::assign(), Parma_Polyhedra_Library::EMPTY, Parma_Polyhedra_Library::UNIVERSE, Parma_Polyhedra_Library::V_EQ, Parma_Polyhedra_Library::V_GE, Parma_Polyhedra_Library::V_GT, Parma_Polyhedra_Library::V_GT_MINUS_INFINITY, Parma_Polyhedra_Library::V_LE, Parma_Polyhedra_Library::V_LGE, Parma_Polyhedra_Library::V_LT, Parma_Polyhedra_Library::V_LT_PLUS_INFINITY, and Parma_Polyhedra_Library::V_NE.

                     {
     Relation_Symbol rs;
     switch (c.rel()) {
     case V_LGE:
     case V_GT_MINUS_INFINITY:
     case V_LT_PLUS_INFINITY:
       return assign(UNIVERSE);
     default:
       return assign(EMPTY);
     case V_LT:
     case V_LE:
     case V_GT:
     case V_GE:
     case V_EQ:
     case V_NE:
       assign(UNIVERSE);
       rs = static_cast<Relation_Symbol>(c.rel());
       return refine_existential(rs, c.value());
     }
   }

template<typename Boundary, typename Info>

template<typename C1 , typename C2 >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C1>::value && Is_Same_Or_Derived<I_Constraint_Base, C2>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::build	(	const C1 &	c1,
		const C2 &	c2
	)

inline

Definition at line 278 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::assign(), Parma_Polyhedra_Library::EMPTY, Parma_Polyhedra_Library::I_CHANGED, Parma_Polyhedra_Library::I_UNCHANGED, Parma_Polyhedra_Library::V_LGE, and Parma_Polyhedra_Library::V_NAN.

                                     {
     switch (c1.rel()) {
     case V_LGE:
       return build(c2);
     case V_NAN:
       return assign(EMPTY);
     default:
       break;
     }
     switch (c2.rel()) {
     case V_LGE:
       return build(c1);
     case V_NAN:
       return assign(EMPTY);
     default:
       break;
     }
     build(c1);
     const I_Result r = add_constraint(c2);
     return r - (I_CHANGED | I_UNCHANGED);
   }

template<typename Boundary, typename Info>

template<typename Type >

Enable_If<Is_Singleton<Type>::value || Is_Interval<Type>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::can_be_exactly_joined_to ( const Type & x ) const

inline

Definition at line 313 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::Boundary_NS::eq(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::Boundary_NS::gt(), Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::lt(), PPL_DIRTY_TEMP, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                                       {
   PPL_DIRTY_TEMP(Boundary, b);
   if (gt(LOWER, lower(), info(), UPPER, f_upper(x), f_info(x))) {
     b = lower();
     return eq(LOWER, b, info(), UPPER, f_upper(x), f_info(x));
   }
   else if (lt(UPPER, upper(), info(), LOWER, f_lower(x), f_info(x))) {
     b = upper();
     return eq(UPPER, b, info(), LOWER, f_lower(x), f_info(x));
   }
   return true;
 }

template<typename Boundary, typename Info>

template<typename Type >

Enable_If<Is_Singleton<Type>::value || Is_Interval<Type>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::can_be_exactly_joined_to ( const Type & x ) const

template<typename Boundary, typename Info>

template<typename From , typename Iterator >

Enable_If<Is_Interval<From>::value, void>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign	(	const From &	y,
		Iterator	first,
		Iterator	last
	)

Definition at line 88 of file Interval_templates.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::lower(), Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_extend(), Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_is_boundary_infinity(), Parma_Polyhedra_Library::Interval< Boundary, Info >::upper(), Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_extend(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_is_boundary_infinity().

                                                               {
   // We assume that `y' is contained in or equal to `*this'.
   PPL_ASSERT(contains(y));
   Interval<Boundary, Info>& x = *this;
 
   // Upper bound.
   if (!x.upper_is_boundary_infinity()) {
     Boundary& x_ub = x.upper();
     const Boundary& y_ub = y.upper();
     PPL_ASSERT(!y.upper_is_boundary_infinity() && y_ub <= x_ub);
     if (y_ub < x_ub) {
       Iterator k = std::lower_bound(first, last, x_ub);
       if (k != last) {
         if (x_ub < *k) {
           x_ub = *k;
         }
       }
       else {
         x.upper_extend();
       }
     }
   }
 
   // Lower bound.
   if (!x.lower_is_boundary_infinity()) {
     Boundary& x_lb = x.lower();
     const Boundary& y_lb = y.lower();
     PPL_ASSERT(!y.lower_is_boundary_infinity() && y_lb >= x_lb);
     if (y_lb > x_lb) {
       Iterator k = std::lower_bound(first, last, x_lb);
       if (k != last) {
         if (x_lb < *k) {
           if (k != first) {
             x_lb = *--k;
           }
           else {
             x.lower_extend();
           }
         }
       }
       else {
         if (k != first) {
           x_lb = *--k;
         }
         else {
           x.lower_extend();
         }
       }
     }
   }
 }

template<typename Boundary, typename Info>

template<typename From , typename Iterator >

Enable_If<Is_Interval<From>::value, void>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign	(	const From &	y,
		Iterator	first,
		Iterator	last
	)

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::check_empty ( I_Result r ) const

inline

Definition at line 177 of file Interval_defs.hh.

References Parma_Polyhedra_Library::I_ANY, Parma_Polyhedra_Library::I_EMPTY, and Parma_Polyhedra_Library::I_NOT_EMPTY.

                                      {
     return (r & I_ANY) == I_EMPTY
       || ((r & I_ANY) != I_NOT_EMPTY && is_empty());
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::contains ( const T & y ) const

inline

Definition at line 193 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::check_empty_arg(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::f_OK(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::Boundary_NS::ge(), Parma_Polyhedra_Library::Boundary_NS::le(), Parma_Polyhedra_Library::Boundary_NS::LOWER, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                    {
   PPL_ASSERT(OK());
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(y)) {
     return true;
   }
   if (check_empty_arg(*this)) {
     return false;
   }
   return le(LOWER, lower(), info(), LOWER, f_lower(y), f_info(y))
     && ge(UPPER, upper(), info(), UPPER, f_upper(y), f_info(y));
 }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::contains ( const T & y ) const

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::contains_integer_point ( ) const

inline

Definition at line 418 of file Interval_defs.hh.

References Parma_Polyhedra_Library::ROUND_DOWN, and Parma_Polyhedra_Library::ROUND_UP.

                                       {
     PPL_ASSERT(OK());
     if (is_empty()) {
       return false;
     }
     if (!is_bounded()) {
       return true;
     }
     Boundary l;
     if (lower_is_open()) {
       add_assign_r(l, lower(), Boundary(1), ROUND_DOWN);
       floor_assign_r(l, l, ROUND_DOWN);
     }
     else {
       ceil_assign_r(l, lower(), ROUND_DOWN);
     }
     Boundary u;
     if (upper_is_open()) {
       sub_assign_r(u, upper(), Boundary(1), ROUND_UP);
       ceil_assign_r(u, u, ROUND_UP);
     }
     else {
       floor_assign_r(u, upper(), ROUND_UP);
     }
     return u >= l;
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::difference_assign ( const From & x )

inline

Definition at line 366 of file Interval_inlines.hh.

                                                                {
   PPL_ASSERT(f_OK(x));
   if (lt(UPPER, upper(), info(), LOWER, f_lower(x), f_info(x))
       || gt(LOWER, lower(), info(), UPPER, f_upper(x), f_info(x))) {
     return combine(V_EQ, V_EQ);
   }
   bool nl = ge(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x));
   bool nu = le(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x));
   Result rl = V_EQ;
   Result ru = V_EQ;
   if (nl) {
     if (nu) {
       return assign(EMPTY);
     }
     else {
       info().clear_boundary_properties(LOWER);
       rl = complement(LOWER, lower(), info(), UPPER, f_upper(x), f_info(x));
     }
   }
   else if (nu) {
     info().clear_boundary_properties(UPPER);
     ru = complement(UPPER, upper(), info(), LOWER, f_lower(x), f_info(x));
   }
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::difference_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

Definition at line 399 of file Interval_inlines.hh.

                                                                   {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   if (lt(UPPER, f_upper(x), f_info(x), LOWER, f_lower(y), f_info(y))
       || gt(LOWER, f_lower(x), f_info(x), UPPER, f_upper(y), f_info(y))) {
     return assign(x);
   }
   bool nl = ge(LOWER, f_lower(x), f_info(x), LOWER, f_lower(y), f_info(y));
   bool nu = le(UPPER, f_upper(x), f_info(x), UPPER, f_upper(y), f_info(y));
   Result rl = V_EQ;
   Result ru = V_EQ;
   if (nl) {
     if (nu) {
       return assign(EMPTY);
     }
     else {
       rl = complement(LOWER, lower(), info(), UPPER, f_upper(y), f_info(y));
       ru = Boundary_NS::assign(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x));
     }
   }
   else if (nu) {
     ru = complement(UPPER, upper(), info(), LOWER, f_lower(y), f_info(y));
     rl = Boundary_NS::assign(LOWER, lower(), info(),
                              LOWER, f_lower(x), f_info(x));
   }
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::difference_assign ( const From & x )

Assigns to *this the smallest interval containing the set-theoretic difference of *this and x.

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::difference_assign	(	const From1 &	x,
		const From2 &	y
	)

Assigns to *this the smallest interval containing the set-theoretic difference of x and y.

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign	(	const From1 &	x,
		const From2 &	y
	)

Referenced by Parma_Polyhedra_Library::operator/().

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

+———–+———–+———–+ | / | yu < 0 | yl > 0 | +———–+———–+———–+ | xu<=0 |xu/yl,xl/yu|xl/yl,xu/yu| +———–+———–+———–+ |xl<=0 xu>=0|xu/yu,xl/yu|xl/yl,xu/yl| +———–+———–+———–+ | xl>=0 |xu/yu,xl/yl|xl/yu,xu/yl| +———–+———–+———–+

Definition at line 889 of file Interval_inlines.hh.

                                                                          {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(x) || check_empty_arg(y)) {
     return assign(EMPTY);
   }
   int yls = sgn_b(LOWER, f_lower(y), f_info(y));
   int yus = (yls > 0) ? 1 : sgn_b(UPPER, f_upper(y), f_info(y));
   if (yls == 0 && yus == 0) {
     return assign(EMPTY);
   }
   int inf_sign = Parma_Polyhedra_Library::infinity_sign(x);
   if (inf_sign != 0) {
     if (Parma_Polyhedra_Library::infinity_sign(y) != 0) {
       return assign(EMPTY);
     }
     if (yls == -yus) {
       return set_infinities();
     }
     if (yls < 0 || yus < 0) {
       inf_sign = -inf_sign;
     }
     if (inf_sign < 0) {
       return assign(MINUS_INFINITY);
     }
     else {
       return assign(PLUS_INFINITY);
     }
   }
   int xls = sgn_b(LOWER, f_lower(x), f_info(x));
   int xus = (xls > 0) ? 1 : sgn_b(UPPER, f_upper(x), f_info(x));
 
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   Result rl;
   Result ru;
   PPL_DIRTY_TEMP(To_Boundary, to_lower);
   if (yls >= 0) {
     if (xls >= 0) {
       rl = div_assign_z(LOWER, to_lower, to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         UPPER, f_upper(y), f_info(y), yus);
       ru = div_assign_z(UPPER, upper(), to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         LOWER, f_lower(y), f_info(y), yls);
     }
     else if (xus <= 0) {
       rl = div_assign_z(LOWER, to_lower, to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         LOWER, f_lower(y), f_info(y), yls);
       ru = div_assign_z(UPPER, upper(), to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         UPPER, f_upper(y), f_info(y), yus);
     }
     else {
       rl = div_assign_z(LOWER, to_lower, to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         LOWER, f_lower(y), f_info(y), yls);
       ru = div_assign_z(UPPER, upper(), to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         LOWER, f_lower(y), f_info(y), yls);
     }
   }
   else if (yus <= 0) {
     if (xls >= 0) {
       rl = div_assign_z(LOWER, to_lower, to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         UPPER, f_upper(y), f_info(y), yus);
       ru = div_assign_z(UPPER, upper(), to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         LOWER, f_lower(y), f_info(y), yls);
     }
     else if (xus <= 0) {
       rl = div_assign_z(LOWER, to_lower, to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         LOWER, f_lower(y), f_info(y), yls);
       ru = div_assign_z(UPPER, upper(), to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         UPPER, f_upper(y), f_info(y), yus);
     }
     else {
       rl = div_assign_z(LOWER, to_lower, to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         UPPER, f_upper(y), f_info(y), yus);
       ru = div_assign_z(UPPER, upper(), to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         UPPER, f_upper(y), f_info(y), yus);
     }
   }
   else {
     return static_cast<I_Result>(assign(UNIVERSE) | I_SINGULARITIES);
   }
   assign_or_swap(lower(), to_lower);
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

void Parma_Polyhedra_Library::Interval< Boundary, Info >::drop_some_non_integer_points ( )

inline

Definition at line 445 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::OPEN, Parma_Polyhedra_Library::ROUND_DOWN, Parma_Polyhedra_Library::ROUND_UP, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                       {
     if (is_empty()) {
       return;
     }
     if (lower_is_open() && !lower_is_boundary_infinity()) {
       add_assign_r(lower(), lower(), Boundary(1), ROUND_DOWN);
       floor_assign_r(lower(), lower(), ROUND_DOWN);
       info().set_boundary_property(LOWER, OPEN, false);
     }
     else {
       ceil_assign_r(lower(), lower(), ROUND_DOWN);
     }
     if (upper_is_open() && !upper_is_boundary_infinity()) {
       sub_assign_r(upper(), upper(), Boundary(1), ROUND_UP);
       ceil_assign_r(upper(), upper(), ROUND_UP);
       info().set_boundary_property(UPPER, OPEN, false);
     }
     else {
       floor_assign_r(upper(), upper(), ROUND_UP);
     }
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Interval<From>::value, void>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::empty_intersection_assign ( const From & )

Definition at line 432 of file Interval_templates.hh.

References Parma_Polyhedra_Library::Boundary_NS::assign(), and Parma_Polyhedra_Library::EMPTY.

                                                                {
   // FIXME: write me.
   assign(EMPTY);
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Interval<From>::value, void>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::empty_intersection_assign ( const From & y )

Assigns to *this an interval having empty intersection with y. The assigned interval should be as large as possible.

template<typename Boundary , typename Info >

memory_size_type Parma_Polyhedra_Library::Interval< Boundary, Info >::external_memory_in_bytes ( ) const

inline

Returns the size in bytes of the memory managed by *this.

Definition at line 31 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::external_memory_in_bytes().

                                                          {
   return Parma_Polyhedra_Library::external_memory_in_bytes(lower())
     + Parma_Polyhedra_Library::external_memory_in_bytes(upper());
 }

template<typename Boundary, typename Info>

int Parma_Polyhedra_Library::Interval< Boundary, Info >::infinity_sign ( ) const

inline

Definition at line 405 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_reverse_infinity(), Parma_Polyhedra_Library::Boundary_NS::LOWER, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

Referenced by Parma_Polyhedra_Library::infinity_sign().

                             {
     PPL_ASSERT(OK());
     if (is_reverse_infinity(LOWER, lower(), info())) {
       return 1;
     }
     else if (is_reverse_infinity(UPPER, upper(), info())) {
       return -1;
     }
     else {
       return 0;
     }
   }

template<typename Boundary, typename Info>

Info& Parma_Polyhedra_Library::Interval< Boundary, Info >::info ( )

inline

Definition at line 132 of file Interval_defs.hh.

Referenced by Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval< Boundary, Info >::m_swap(), and Parma_Polyhedra_Library::operator>>().

                {
     return *this;
   }

template<typename Boundary, typename Info>

const Info& Parma_Polyhedra_Library::Interval< Boundary, Info >::info ( ) const

inline

Definition at line 136 of file Interval_defs.hh.

                            {
     return *this;
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign ( const From & x )

inline

Definition at line 331 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::f_OK(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::I_ANY, Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::max_assign(), Parma_Polyhedra_Library::min_assign(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                               {
   PPL_ASSERT(f_OK(x));
   max_assign(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x));
   min_assign(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x));
   PPL_ASSERT(OK());
   return I_ANY;
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

Definition at line 345 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::assign_or_swap(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::f_OK(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::I_NOT_EMPTY, Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::max_assign(), Parma_Polyhedra_Library::min_assign(), PPL_DIRTY_TEMP, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                                  {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   max_assign(LOWER, lower(), to_info,
              LOWER, f_lower(x), f_info(x),
              LOWER, f_lower(y), f_info(y));
   min_assign(UPPER, upper(), to_info,
              UPPER, f_upper(x), f_info(x),
              UPPER, f_upper(y), f_info(y));
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return I_NOT_EMPTY;
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign ( const From & x )

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign	(	const From1 &	x,
		const From2 &	y
	)

template<typename Boundary, typename Info>

static bool Parma_Polyhedra_Library::Interval< Boundary, Info >::is_always_topologically_closed ( )

inlinestatic

Definition at line 364 of file Interval_defs.hh.

                                                {
     return !Info::store_open;
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::is_bounded ( ) const

inline

Definition at line 216 of file Interval_defs.hh.

                           {
     PPL_ASSERT(OK());
     return !lower_is_boundary_infinity() && !upper_is_boundary_infinity();
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::is_disjoint_from ( const T & y ) const

inline

Definition at line 229 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::check_empty_arg(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::f_OK(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::Boundary_NS::gt(), Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::lt(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                            {
   PPL_ASSERT(OK());
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(*this) || check_empty_arg(y)) {
     return true;
   }
   return gt(LOWER, lower(), info(), UPPER, f_upper(y), f_info(y))
     || lt(UPPER, upper(), info(), LOWER, f_lower(y), f_info(y));
 }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::is_disjoint_from ( const T & y ) const

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::is_empty ( ) const

inline

Definition at line 173 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::lt(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

Referenced by Parma_Polyhedra_Library::f_is_empty().

                         {
     return lt(UPPER, upper(), info(), LOWER, lower(), info());
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::is_singleton ( ) const

inline

Definition at line 182 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::eq(), Parma_Polyhedra_Library::Boundary_NS::LOWER, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

Referenced by Parma_Polyhedra_Library::f_is_singleton().

                             {
     return eq(LOWER, lower(), info(), UPPER, upper(), info());
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::is_topologically_closed ( ) const

inline

Definition at line 368 of file Interval_defs.hh.

                                        {
     PPL_ASSERT(OK());
     return is_always_topologically_closed()
       || is_empty()
       || ((lower_is_boundary_infinity() || !lower_is_open())
           && (upper_is_boundary_infinity() || !upper_is_open()));
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::is_universe ( ) const

inline

Definition at line 221 of file Interval_defs.hh.

                            {
     PPL_ASSERT(OK());
     return lower_is_domain_inf() && upper_is_domain_sup();
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign ( const From & x )

inline

Definition at line 263 of file Interval_inlines.hh.

                                                          {
   PPL_ASSERT(f_OK(x));
   if (check_empty_arg(*this)) {
     return assign(x);
   }
   if (check_empty_arg(x)) {
     return combine(V_EQ, V_EQ);
   }
   Result rl;
   Result ru;
   rl = min_assign(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x));
   ru = max_assign(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x));
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

Definition at line 285 of file Interval_inlines.hh.

                                                                           {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(x)) {
     return assign(y);
   }
   if (check_empty_arg(y)) {
     return assign(x);
   }
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   Result rl;
   Result ru;
   rl = min_assign(LOWER, lower(), to_info,
                   LOWER, f_lower(x), f_info(x),
                   LOWER, f_lower(y), f_info(y));
   ru = max_assign(UPPER, upper(), to_info,
                   UPPER, f_upper(x), f_info(x),
                   UPPER, f_upper(y), f_info(y));
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign ( const From & x )

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign	(	const From1 &	x,
		const From2 &	y
	)

template<typename Boundary, typename Info>

Boundary& Parma_Polyhedra_Library::Interval< Boundary, Info >::lower ( )

inline

Definition at line 140 of file Interval_defs.hh.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::BD_Shape< T >::inhomogeneous_affine_form_image(), Parma_Polyhedra_Library::Interval< Boundary, Info >::m_swap(), Parma_Polyhedra_Library::BD_Shape< T >::one_variable_affine_form_image(), and Parma_Polyhedra_Library::operator>>().

                     {
     return lower_;
   }

template<typename Boundary, typename Info>

const Boundary& Parma_Polyhedra_Library::Interval< Boundary, Info >::lower ( ) const

inline

Definition at line 144 of file Interval_defs.hh.

                                 {
     return lower_;
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_approximation_difference_assign ( const From & x )

Assigns to *this the largest interval contained in the set-theoretic difference of *this and x.

template<typename Boundary, typename Info>

I_Constraint<boundary_type> Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_constraint ( ) const

inline

Definition at line 156 of file Interval_defs.hh.

References Parma_Polyhedra_Library::GREATER_OR_EQUAL, Parma_Polyhedra_Library::GREATER_THAN, Parma_Polyhedra_Library::i_constraint(), Parma_Polyhedra_Library::Boundary_NS::LOWER, and Parma_Polyhedra_Library::Boundary_NS::SPECIAL.

                                                        {
     PPL_ASSERT(!is_empty());
     if (info().get_boundary_property(LOWER, SPECIAL)) {
       return I_Constraint<boundary_type>();
     }
     return i_constraint(lower_is_open() ? GREATER_THAN : GREATER_OR_EQUAL,
                         lower(), true);
   }

template<typename Boundary, typename Info>

template<typename C >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_extend ( const C & c )

Definition at line 34 of file Interval_templates.hh.

References Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::I_ANY, Parma_Polyhedra_Library::I_EXACT, Parma_Polyhedra_Library::I_NOT_EMPTY, Parma_Polyhedra_Library::I_UNCHANGED, Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::min_assign(), Parma_Polyhedra_Library::V_EQ, Parma_Polyhedra_Library::V_GE, Parma_Polyhedra_Library::V_GT, Parma_Polyhedra_Library::V_LGE, and Parma_Polyhedra_Library::V_NAN.

                                                  {
   PPL_ASSERT(OK());
   bool open;
   switch (c.rel()) {
   case V_LGE:
     return lower_extend();
   case V_NAN:
     return I_NOT_EMPTY | I_EXACT | I_UNCHANGED;
   case V_GT:
     open = true;
     break;
   case V_GE: // Fall through.
   case V_EQ:
     open = false;
     break;
   default:
     PPL_UNREACHABLE;
     return I_NOT_EMPTY | I_EXACT | I_UNCHANGED;
   }
   min_assign(LOWER, lower(), info(), LOWER, c.value(), f_info(c.value(), open));
   PPL_ASSERT(OK());
   return I_ANY;
 }

template<typename Boundary, typename Info>

I_Result Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_extend ( )

inline

Definition at line 226 of file Interval_defs.hh.

References Parma_Polyhedra_Library::I_ANY, Parma_Polyhedra_Library::Boundary_NS::LOWER, and Parma_Polyhedra_Library::Boundary_NS::set_unbounded().

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign().

                           {
     info().clear_boundary_properties(LOWER);
     set_unbounded(LOWER, lower(), info());
     return I_ANY;
   }

template<typename Boundary, typename Info>

template<typename C >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_extend ( const C & c )

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_is_boundary_infinity ( ) const

inline

Definition at line 196 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_boundary_infinity(), and Parma_Polyhedra_Library::Boundary_NS::LOWER.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign().

                                           {
     PPL_ASSERT(OK());
     return Boundary_NS::is_boundary_infinity(LOWER, lower(), info());
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_is_domain_inf ( ) const

inline

Definition at line 206 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_domain_inf(), and Parma_Polyhedra_Library::Boundary_NS::LOWER.

                                    {
     PPL_ASSERT(OK());
     return Boundary_NS::is_domain_inf(LOWER, lower(), info());
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_is_open ( ) const

inline

Definition at line 186 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_open(), and Parma_Polyhedra_Library::Boundary_NS::LOWER.

                              {
     PPL_ASSERT(OK());
     return is_open(LOWER, lower(), info());
   }

template<typename Boundary , typename Info >

void Parma_Polyhedra_Library::Interval< Boundary, Info >::m_swap ( Interval< Boundary, Info > & y )

inline

Swaps *this with y.

Definition at line 44 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::info(), Parma_Polyhedra_Library::Interval< Boundary, Info >::lower(), Parma_Polyhedra_Library::swap(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::upper().

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::swap().

                                                             {
   using std::swap;
   swap(lower(), y.lower());
   swap(upper(), y.upper());
   swap(info(), y.info());
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

+———+———–+———–+—————–+ | * | yl > 0 | yu < 0 | yl < 0, yu > 0 | +———+———–+———–+—————–+ | xl > 0 |xl*yl,xu*yu|xu*yl,xl*yu| xu*yl,xu*yu | +———+———–+———–+—————–+ | xu < 0 |xl*yu,xu*yl|xu*yu,xl*yl| xl*yu,xl*yl | +———+———–+———–+—————–+ |xl<0 xu>0|xl*yu,xu*yu|xu*yl,xl*yl|min(xl*yu,xu*yl),| | | | |max(xl*yl,xu*yu) | +———+———–+———–+—————–+

Definition at line 714 of file Interval_inlines.hh.

                                                                          {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(x) || check_empty_arg(y)) {
     return assign(EMPTY);
   }
   int xls = sgn_b(LOWER, f_lower(x), f_info(x));
   int xus = (xls > 0) ? 1 : sgn_b(UPPER, f_upper(x), f_info(x));
   int yls = sgn_b(LOWER, f_lower(y), f_info(y));
   int yus = (yls > 0) ? 1 : sgn_b(UPPER, f_upper(y), f_info(y));
   int inf_sign = Parma_Polyhedra_Library::infinity_sign(x);
   int ls;
   int us;
   if (inf_sign != 0) {
     ls = yls;
     us = yus;
     goto inf;
   }
   else {
     inf_sign = Parma_Polyhedra_Library::infinity_sign(y);
     if (inf_sign != 0) {
       ls = xls;
       us = xus;
     inf:
       if (ls == 0 && us == 0) {
         return assign(EMPTY);
       }
       if (ls == -us) {
         return set_infinities();
       }
       if (ls < 0 || us < 0) {
         inf_sign = -inf_sign;
       }
       if (inf_sign < 0) {
         return assign(MINUS_INFINITY);
       }
       else {
         return assign(PLUS_INFINITY);
       }
     }
   }
 
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   Result rl;
   Result ru;
   PPL_DIRTY_TEMP(To_Boundary, to_lower);
 
   if (xls >= 0) {
     if (yls >= 0) {
       // 0 <= xl <= xu, 0 <= yl <= yu
       rl = mul_assign_z(LOWER, to_lower, to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         LOWER, f_lower(y), f_info(y), yls);
       ru = mul_assign_z(UPPER, upper(), to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         UPPER, f_upper(y), f_info(y), yus);
     }
     else if (yus <= 0) {
       // 0 <= xl <= xu, yl <= yu <= 0
       rl = mul_assign_z(LOWER, to_lower, to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         LOWER, f_lower(y), f_info(y), yls);
       ru = mul_assign_z(UPPER, upper(), to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         UPPER, f_upper(y), f_info(y), yus);
     }
     else {
       // 0 <= xl <= xu, yl < 0 < yu
       rl = mul_assign_z(LOWER, to_lower, to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         LOWER, f_lower(y), f_info(y), yls);
       ru = mul_assign_z(UPPER, upper(), to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         UPPER, f_upper(y), f_info(y), yus);
     }
   }
   else if (xus <= 0) {
     if (yls >= 0) {
       // xl <= xu <= 0, 0 <= yl <= yu
       rl = mul_assign_z(LOWER, to_lower, to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         UPPER, f_upper(y), f_info(y), yus);
       ru = mul_assign_z(UPPER, upper(), to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         LOWER, f_lower(y), f_info(y), yls);
     }
     else if (yus <= 0) {
       // xl <= xu <= 0, yl <= yu <= 0
       rl = mul_assign_z(LOWER, to_lower, to_info,
                         UPPER, f_upper(x), f_info(x), xus,
                         UPPER, f_upper(y), f_info(y), yus);
       ru = mul_assign_z(UPPER, upper(), to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         LOWER, f_lower(y), f_info(y), yls);
     }
     else {
       // xl <= xu <= 0, yl < 0 < yu
       rl = mul_assign_z(LOWER, to_lower, to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         UPPER, f_upper(y), f_info(y), yus);
       ru = mul_assign_z(UPPER, upper(), to_info,
                         LOWER, f_lower(x), f_info(x), xls,
                         LOWER, f_lower(y), f_info(y), yls);
     }
   }
   else if (yls >= 0) {
     // xl < 0 < xu, 0 <= yl <= yu
     rl = mul_assign_z(LOWER, to_lower, to_info,
                       LOWER, f_lower(x), f_info(x), xls,
                       UPPER, f_upper(y), f_info(y), yus);
     ru = mul_assign_z(UPPER, upper(), to_info,
                       UPPER, f_upper(x), f_info(x), xus,
                       UPPER, f_upper(y), f_info(y), yus);
   }
   else if (yus <= 0) {
     // xl < 0 < xu, yl <= yu <= 0
     rl = mul_assign_z(LOWER, to_lower, to_info,
                       UPPER, f_upper(x), f_info(x), xus,
                       LOWER, f_lower(y), f_info(y), yls);
     ru = mul_assign_z(UPPER, upper(), to_info,
                       LOWER, f_lower(x), f_info(x), xls,
                       LOWER, f_lower(y), f_info(y), yls);
   }
   else {
     // xl < 0 < xu, yl < 0 < yu
     PPL_DIRTY_TEMP(To_Boundary, tmp);
     PPL_DIRTY_TEMP(To_Info, tmp_info);
     tmp_info.clear();
     Result tmp_r;
     tmp_r = Boundary_NS::mul_assign(LOWER, tmp, tmp_info,
                                     UPPER, f_upper(x), f_info(x),
                                     LOWER, f_lower(y), f_info(y));
     rl = Boundary_NS::mul_assign(LOWER, to_lower, to_info,
                                  LOWER, f_lower(x), f_info(x),
                                  UPPER, f_upper(y), f_info(y));
     if (gt(LOWER, to_lower, to_info, LOWER, tmp, tmp_info)) {
       to_lower = tmp;
       rl = tmp_r;
     }
     tmp_info.clear();
     tmp_r = Boundary_NS::mul_assign(UPPER, tmp, tmp_info,
                                     UPPER, f_upper(x), f_info(x),
                                     UPPER, f_upper(y), f_info(y));
     ru = Boundary_NS::mul_assign(UPPER, upper(), to_info,
                                  LOWER, f_lower(x), f_info(x),
                                  LOWER, f_lower(y), f_info(y));
     if (lt(UPPER, upper(), to_info, UPPER, tmp, tmp_info)) {
       upper() = tmp;
       ru = tmp_r;
     }
   }
   assign_or_swap(lower(), to_lower);
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign	(	const From1 &	x,
		const From2 &	y
	)

Referenced by Parma_Polyhedra_Library::operator*().

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign ( const From & x )

inline

Definition at line 594 of file Interval_inlines.hh.

                                                         {
   PPL_ASSERT(f_OK(x));
   if (check_empty_arg(x)) {
     return assign(EMPTY);
   }
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   Result rl;
   Result ru;
   PPL_DIRTY_TEMP(To_Boundary, to_lower);
   rl = Boundary_NS::neg_assign(LOWER, to_lower, to_info, UPPER, f_upper(x), f_info(x));
   ru = Boundary_NS::neg_assign(UPPER, upper(), to_info, LOWER, f_lower(x), f_info(x));
   assign_or_swap(lower(), to_lower);
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value || Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign ( const From & x )

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::OK ( ) const

inline

Definition at line 524 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_minus_infinity(), Parma_Polyhedra_Library::is_not_a_number(), Parma_Polyhedra_Library::Boundary_NS::is_open(), Parma_Polyhedra_Library::Boundary_NS::is_plus_infinity(), Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::SPECIAL, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                   {
     if (!Info::may_be_empty && is_empty()) {
 #ifndef NDEBUG
       std::cerr << "The interval is unexpectedly empty.\n";
 #endif
       return false;
     }
 
     if (is_open(LOWER, lower(), info())) {
       if (is_plus_infinity(LOWER, lower(), info())) {
 #ifndef NDEBUG
         std::cerr << "The lower boundary is +inf open.\n";
 #endif
       }
     }
     else if (!Info::may_contain_infinity
              && (is_minus_infinity(LOWER, lower(), info())
                  || is_plus_infinity(LOWER, lower(), info()))) {
 #ifndef NDEBUG
       std::cerr << "The lower boundary is unexpectedly infinity.\n";
 #endif
       return false;
     }
     if (!info().get_boundary_property(LOWER, SPECIAL)) {
       if (is_not_a_number(lower())) {
 #ifndef NDEBUG
         std::cerr << "The lower boundary is not a number.\n";
 #endif
         return false;
       }
     }
 
     if (is_open(UPPER, upper(), info())) {
       if (is_minus_infinity(UPPER, upper(), info())) {
 #ifndef NDEBUG
         std::cerr << "The upper boundary is -inf open.\n";
 #endif
       }
     }
     else if (!Info::may_contain_infinity
              && (is_minus_infinity(UPPER, upper(), info())
                  || is_plus_infinity(UPPER, upper(), info()))) {
 #ifndef NDEBUG
       std::cerr << "The upper boundary is unexpectedly infinity."
                 << std::endl;
 #endif
       return false;
     }
     if (!info().get_boundary_property(UPPER, SPECIAL)) {
       if (is_not_a_number(upper())) {
 #ifndef NDEBUG
         std::cerr << "The upper boundary is not a number.\n";
 #endif
         return false;
       }
     }
 
     // Everything OK.
     return true;
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, Interval&>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::operator*= ( const T & x )

inline

Definition at line 118 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::mul_assign().

                          {
     mul_assign(*this, x);
     return *this;
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, Interval&>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::operator+= ( const T & x )

inline

Definition at line 106 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::add_assign().

                          {
     add_assign(*this, x);
     return *this;
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, Interval&>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::operator-= ( const T & x )

inline

Definition at line 112 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::sub_assign().

                          {
     sub_assign(*this, x);
     return *this;
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, Interval&>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::operator/= ( const T & x )

inline

Definition at line 124 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::div_assign().

                          {
     div_assign(*this, x);
     return *this;
   }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, Interval&>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::operator= ( const T & x )

inline

Definition at line 99 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::assign().

                         {
     assign(x);
     return *this;
   }

template<typename Boundary, typename Info>

Parma_Polyhedra_Library::Interval< Boundary, Info >::PPL_COMPILE_TIME_CHECK	(	!Info::store_special\|\|!std::numeric_limits< Boundary >::has_infinity	,
		"store_special is meaningless"" when boundary type may contains infinity"
	)

private

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value \|\| Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential	(	Relation_Symbol	rel,
		const From &	x
	)

inline

Definition at line 437 of file Interval_inlines.hh.

                                                        {
   PPL_ASSERT(OK());
   PPL_ASSERT(f_OK(x));
   if (check_empty_arg(x)) {
     return assign(EMPTY);
   }
   switch (rel) {
   case LESS_THAN:
     {
       if (lt(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(UPPER);
       Boundary_NS::assign(UPPER, upper(), info(),
                           UPPER, f_upper(x), f_info(x), true);
       return I_ANY;
     }
   case LESS_OR_EQUAL:
     {
       if (le(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(UPPER);
       Boundary_NS::assign(UPPER, upper(), info(),
                           UPPER, f_upper(x), f_info(x));
       return I_ANY;
     }
   case GREATER_THAN:
     {
       if (gt(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(LOWER);
       Boundary_NS::assign(LOWER, lower(), info(),
                           LOWER, f_lower(x), f_info(x), true);
       return I_ANY;
     }
   case GREATER_OR_EQUAL:
     {
       if (ge(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(LOWER);
       Boundary_NS::assign(LOWER, lower(), info(),
                           LOWER, f_lower(x), f_info(x));
       return I_ANY;
     }
   case EQUAL:
     return intersect_assign(x);
   case NOT_EQUAL:
     {
       if (!f_is_singleton(x)) {
         return combine(V_EQ, V_EQ);
       }
       if (check_empty_arg(*this)) {
         return I_EMPTY;
       }
       if (eq(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x))) {
         remove_inf();
       }
       if (eq(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x))) {
         remove_sup();
       }
       return I_ANY;
     }
   default:
     PPL_UNREACHABLE;
     return I_EMPTY;
   }
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value \|\| Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential	(	Relation_Symbol	rel,
		const From &	x
	)

Refines to according to the existential relation rel with x.

The to interval is restricted to become, upon successful exit, the smallest interval of its type that contains the set

$\{\, a \in \mathtt{to} \mid \exists b \in \mathtt{x} \st a \mathrel{\mathtt{rel}} b \,\}.$

Returns: ???

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value \|\| Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal	(	Relation_Symbol	rel,
		const From &	x
	)

inline

Definition at line 512 of file Interval_inlines.hh.

                                                                 {
   PPL_ASSERT(OK());
   PPL_ASSERT(f_OK(x));
   if (check_empty_arg(x)) {
     return combine(V_EQ, V_EQ);
   }
   switch (rel) {
   case LESS_THAN:
     {
       if (lt(UPPER, upper(), info(), LOWER, f_lower(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(UPPER);
       Result ru = Boundary_NS::assign(UPPER, upper(), info(),
                                       LOWER, f_lower(x), SCALAR_INFO,
                                       !is_open(LOWER, f_lower(x), f_info(x)));
       PPL_USED(ru);
       return I_ANY;
     }
   case LESS_OR_EQUAL:
     {
       if (le(UPPER, upper(), info(), LOWER, f_lower(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(UPPER);
       Result ru = Boundary_NS::assign(UPPER, upper(), info(),
                                       LOWER, f_lower(x), SCALAR_INFO);
       PPL_USED(ru);
       return I_ANY;
     }
   case GREATER_THAN:
     {
       if (gt(LOWER, lower(), info(), UPPER, f_upper(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(LOWER);
       Result rl = Boundary_NS::assign(LOWER, lower(), info(),
                                       UPPER, f_upper(x), SCALAR_INFO,
                                       !is_open(UPPER, f_upper(x), f_info(x)));
       PPL_USED(rl);
       return I_ANY;
     }
   case GREATER_OR_EQUAL:
     {
       if (ge(LOWER, lower(), info(), UPPER, f_upper(x), f_info(x))) {
         return combine(V_EQ, V_EQ);
       }
       info().clear_boundary_properties(LOWER);
       Result rl = Boundary_NS::assign(LOWER, lower(), info(),
                                       UPPER, f_upper(x), SCALAR_INFO);
       PPL_USED(rl);
       return I_ANY;
     }
   case EQUAL:
     if (!f_is_singleton(x)) {
       return assign(EMPTY);
     }
     return intersect_assign(x);
   case NOT_EQUAL:
     {
       if (check_empty_arg(*this)) {
         return I_EMPTY;
       }
       if (eq(LOWER, lower(), info(), LOWER, f_lower(x), f_info(x))) {
         remove_inf();
       }
       if (eq(UPPER, upper(), info(), UPPER, f_upper(x), f_info(x))) {
         remove_sup();
       }
       return I_ANY;
     }
   default:
     PPL_UNREACHABLE;
     return I_EMPTY;
   }
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value \|\| Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal	(	Relation_Symbol	rel,
		const From &	x
	)

Refines to so that it satisfies the universal relation rel with x.

The to interval is restricted to become, upon successful exit, the smallest interval of its type that contains the set

$\{\, a \in \mathtt{to} \mid \forall b \in \mathtt{x} \itc a \mathrel{\mathtt{rel}} b \,\}.$

Returns: ???

template<typename Boundary, typename Info>

void Parma_Polyhedra_Library::Interval< Boundary, Info >::remove_inf ( )

inline

Definition at line 389 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::LOWER, and Parma_Polyhedra_Library::Boundary_NS::OPEN.

                     {
     PPL_ASSERT(!is_empty());
     if (!Info::store_open) {
       return;
     }
     info().set_boundary_property(LOWER, OPEN, true);
   }

template<typename Boundary, typename Info>

void Parma_Polyhedra_Library::Interval< Boundary, Info >::remove_sup ( )

inline

Definition at line 397 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::OPEN, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                     {
     PPL_ASSERT(!is_empty());
     if (!Info::store_open) {
       return;
     }
     info().set_boundary_property(UPPER, OPEN, true);
   }

template<typename Boundary, typename Info>

I_Result Parma_Polyhedra_Library::Interval< Boundary, Info >::set_infinities ( )

inline

Definition at line 356 of file Interval_defs.hh.

References Parma_Polyhedra_Library::combine(), Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::set_minus_infinity(), Parma_Polyhedra_Library::Boundary_NS::set_plus_infinity(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                             {
     info().clear();
     Result rl = Boundary_NS::set_minus_infinity(LOWER, lower(), info());
     Result ru = Boundary_NS::set_plus_infinity(UPPER, upper(), info());
     PPL_ASSERT(OK());
     return combine(rl, ru);
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Interval<From>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::simplify_using_context_assign ( const From & y )

Definition at line 406 of file Interval_templates.hh.

References Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::Boundary_NS::gt(), Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::lt(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                                      {
   // FIXME: the following code wrongly assumes that intervals are closed
   if (lt(UPPER, upper(), info(), LOWER, f_lower(y), f_info(y))) {
     lower_extend();
     return false;
   }
   if (gt(LOWER, lower(), info(), UPPER, f_upper(y), f_info(y))) {
     upper_extend();
     return false;
   }
   // Weakening the upper bound.
   if (!upper_is_boundary_infinity() && !y.upper_is_boundary_infinity()
       && y.upper() <= upper()) {
     upper_extend();
   }
   // Weakening the lower bound.
   if (!lower_is_boundary_infinity() && !y.lower_is_boundary_infinity()
       && y.lower() >= lower()) {
     lower_extend();
   }
   return true;
 }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Interval<From>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::simplify_using_context_assign ( const From & y )

Assigns to *this a meet-preserving simplification of *this with respect to y.

Returns: false if and only if the meet of *this and y is empty.

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains ( const T & y ) const

inline

Definition at line 210 of file Interval_inlines.hh.

                                                             {
   PPL_ASSERT(OK());
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(y)) {
     return !check_empty_arg(*this);
   }
   if (check_empty_arg(*this)) {
     return false;
   }
   return (lt(LOWER, lower(), info(), LOWER, f_lower(y), f_info(y))
           && ge(UPPER, upper(), info(), UPPER, f_upper(y), f_info(y)))
     || (le(LOWER, lower(), info(), LOWER, f_lower(y), f_info(y))
         && gt(UPPER, upper(), info(), UPPER, f_upper(y), f_info(y)));
 }

template<typename Boundary, typename Info>

template<typename T >

Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains ( const T & y ) const

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign	(	const From1 &	x,
		const From2 &	y
	)

inline

Definition at line 658 of file Interval_inlines.hh.

                                                                          {
   PPL_ASSERT(f_OK(x));
   PPL_ASSERT(f_OK(y));
   if (check_empty_arg(x) || check_empty_arg(y)) {
     return assign(EMPTY);
   }
   int inf_sign = Parma_Polyhedra_Library::infinity_sign(x);
   if (inf_sign != 0) {
     if (Parma_Polyhedra_Library::infinity_sign(y) == inf_sign) {
       return assign(EMPTY);
     }
   }
   else {
     inf_sign = -Parma_Polyhedra_Library::infinity_sign(y);
   }
   if (inf_sign < 0) {
     return assign(MINUS_INFINITY);
   }
   else if (inf_sign > 0) {
     return assign(PLUS_INFINITY);
   }
   PPL_DIRTY_TEMP(To_Info, to_info);
   to_info.clear();
   Result rl;
   Result ru;
   PPL_DIRTY_TEMP(To_Boundary, to_lower);
   rl = Boundary_NS::sub_assign(LOWER, to_lower, to_info,
                                LOWER, f_lower(x), f_info(x),
                                UPPER, f_upper(y), f_info(y));
   ru = Boundary_NS::sub_assign(UPPER, upper(), to_info,
                                UPPER, f_upper(x), f_info(x),
                                LOWER, f_lower(y), f_info(y));
   assign_or_swap(lower(), to_lower);
   assign_or_swap(info(), to_info);
   PPL_ASSERT(OK());
   return combine(rl, ru);
 }

template<typename Boundary, typename Info>

template<typename From1 , typename From2 >

Enable_If<((Is_Singleton<From1>::value \|\| Is_Interval<From1>::value) && (Is_Singleton<From2>::value \|\| Is_Interval<From2>::value)), I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign	(	const From1 &	x,
		const From2 &	y
	)

Referenced by Parma_Polyhedra_Library::operator-().

template<typename Boundary, typename Info>

void Parma_Polyhedra_Library::Interval< Boundary, Info >::topological_closure_assign ( )

inline

Assigns to *this its topological closure.

Definition at line 377 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::LOWER, Parma_Polyhedra_Library::Boundary_NS::OPEN, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                     {
     if (!Info::store_open || is_empty()) {
       return;
     }
     if (lower_is_open() && !lower_is_boundary_infinity()) {
       info().set_boundary_property(LOWER, OPEN, false);
     }
     if (upper_is_open() && !upper_is_boundary_infinity()) {
       info().set_boundary_property(UPPER, OPEN, false);
     }
   }

template<typename Boundary , typename Info >

memory_size_type Parma_Polyhedra_Library::Interval< Boundary, Info >::total_memory_in_bytes ( ) const

inline

Returns the total size in bytes of the memory occupied by *this.

Definition at line 38 of file Interval_inlines.hh.

References Parma_Polyhedra_Library::external_memory_in_bytes().

                                                       {
   return sizeof(*this) + external_memory_in_bytes();
 }

template<typename Boundary, typename Info>

Boundary& Parma_Polyhedra_Library::Interval< Boundary, Info >::upper ( )

inline

Definition at line 148 of file Interval_defs.hh.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::BD_Shape< T >::inhomogeneous_affine_form_image(), Parma_Polyhedra_Library::Interval< Boundary, Info >::m_swap(), Parma_Polyhedra_Library::BD_Shape< T >::one_variable_affine_form_image(), and Parma_Polyhedra_Library::operator>>().

                     {
     return upper_;
   }

template<typename Boundary, typename Info>

const Boundary& Parma_Polyhedra_Library::Interval< Boundary, Info >::upper ( ) const

inline

Definition at line 152 of file Interval_defs.hh.

                                 {
     return upper_;
   }

template<typename Boundary, typename Info>

I_Constraint<boundary_type> Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_constraint ( ) const

inline

Definition at line 164 of file Interval_defs.hh.

References Parma_Polyhedra_Library::i_constraint(), Parma_Polyhedra_Library::LESS_OR_EQUAL, Parma_Polyhedra_Library::LESS_THAN, Parma_Polyhedra_Library::Boundary_NS::SPECIAL, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                        {
     PPL_ASSERT(!is_empty());
     if (info().get_boundary_property(UPPER, SPECIAL)) {
       return I_Constraint<boundary_type>();
     }
     return i_constraint(upper_is_open() ? LESS_THAN : LESS_OR_EQUAL,
                         upper(), true);
   }

template<typename Boundary, typename Info>

template<typename C >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_extend ( const C & c )

Definition at line 61 of file Interval_templates.hh.

References Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::I_ANY, Parma_Polyhedra_Library::I_EXACT, Parma_Polyhedra_Library::I_NOT_EMPTY, Parma_Polyhedra_Library::I_UNCHANGED, Parma_Polyhedra_Library::max_assign(), Parma_Polyhedra_Library::Boundary_NS::UPPER, Parma_Polyhedra_Library::V_EQ, Parma_Polyhedra_Library::V_LE, Parma_Polyhedra_Library::V_LGE, Parma_Polyhedra_Library::V_LT, and Parma_Polyhedra_Library::V_NAN.

                                                  {
   PPL_ASSERT(OK());
   bool open;
   switch (c.rel()) {
   case V_LGE:
     return lower_extend();
   case V_NAN:
     return I_NOT_EMPTY | I_EXACT | I_UNCHANGED;
   case V_LT:
     open = true;
     break;
   case V_LE: // Fall through.
   case V_EQ:
     open = false;
     break;
   default:
     PPL_UNREACHABLE;
     return I_NOT_EMPTY | I_EXACT | I_UNCHANGED;
   }
   max_assign(UPPER, upper(), info(), UPPER, c.value(), f_info(c.value(), open));
   PPL_ASSERT(OK());
   return I_ANY;
 }

template<typename Boundary, typename Info>

I_Result Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_extend ( )

inline

Definition at line 236 of file Interval_defs.hh.

References Parma_Polyhedra_Library::I_ANY, Parma_Polyhedra_Library::Boundary_NS::set_unbounded(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign().

                           {
     info().clear_boundary_properties(UPPER);
     set_unbounded(UPPER, upper(), info());
     return I_ANY;
   }

template<typename Boundary, typename Info>

template<typename C >

Enable_If<Is_Same_Or_Derived<I_Constraint_Base, C>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_extend ( const C & c )

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_is_boundary_infinity ( ) const

inline

Definition at line 201 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_boundary_infinity(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::CC76_widening_assign().

                                           {
     PPL_ASSERT(OK());
     return Boundary_NS::is_boundary_infinity(UPPER, upper(), info());
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_is_domain_sup ( ) const

inline

Definition at line 211 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_domain_sup(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                    {
     PPL_ASSERT(OK());
     return Boundary_NS::is_domain_sup(UPPER, upper(), info());
   }

template<typename Boundary, typename Info>

bool Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_is_open ( ) const

inline

Definition at line 191 of file Interval_defs.hh.

References Parma_Polyhedra_Library::Boundary_NS::is_open(), and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                              {
     PPL_ASSERT(OK());
     return is_open(UPPER, upper(), info());
   }

template<typename Boundary, typename Info>

Info& Parma_Polyhedra_Library::Interval< Boundary, Info >::w_info ( ) const

inlineprivate

Definition at line 87 of file Interval_defs.hh.

                        {
     return const_cast<Interval&>(*this);
   }

template<typename Boundary, typename Info>

template<typename From >

Enable_If<Is_Singleton<From>::value \|\| Is_Interval<From>::value, I_Result>::type Parma_Polyhedra_Library::Interval< Boundary, Info >::wrap_assign	(	Bounded_Integer_Type_Width	w,
		Bounded_Integer_Type_Representation	r,
		const From &	refinement
	)

inline

Definition at line 469 of file Interval_defs.hh.

                                       {
     if (is_empty()) {
       return I_EMPTY;
     }
     if (lower_is_boundary_infinity() || upper_is_boundary_infinity()) {
       return assign(refinement);
     }
     PPL_DIRTY_TEMP(Boundary, u);
     Result result = sub_2exp_assign_r(u, upper(), w, ROUND_UP);
     if (result_overflow(result) == 0 && u > lower()) {
       return assign(refinement);
     }
     info().clear();
     switch (r) {
     case UNSIGNED:
       umod_2exp_assign(LOWER, lower(), info(),
                        LOWER, lower(), info(), w);
       umod_2exp_assign(UPPER, upper(), info(),
                        UPPER, upper(), info(), w);
       break;
     case SIGNED_2_COMPLEMENT:
       smod_2exp_assign(LOWER, lower(), info(),
                        LOWER, lower(), info(), w);
       smod_2exp_assign(UPPER, upper(), info(),
                        UPPER, upper(), info(), w);
       break;
     default:
       PPL_UNREACHABLE;
       break;
     }
     if (le(LOWER, lower(), info(), UPPER, upper(), info())) {
       return intersect_assign(refinement);
     }
     PPL_DIRTY_TEMP(Interval, tmp);
     tmp.info().clear();
     Boundary_NS::assign(LOWER, tmp.lower(), tmp.info(),
                         LOWER, lower(), info());
     set_unbounded(UPPER, tmp.upper(), tmp.info());
     tmp.intersect_assign(refinement);
     lower_extend();
     intersect_assign(refinement);
     return join_assign(tmp);
   }

Friends And Related Function Documentation

template<typename Boundary , typename Info >

void swap	(	Interval< Boundary, Info > &	x,
		Interval< Boundary, Info > &	y
	)

template<typename Boundary , typename Info >

void swap	(	Interval< Boundary, Info > &	x,
		Interval< Boundary, Info > &	y
	)

References Parma_Polyhedra_Library::Interval< Boundary, Info >::m_swap().

                                                                {
   x.m_swap(y);
 }

Member Data Documentation

template<typename Boundary, typename Info>

Boundary Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_

private

Definition at line 767 of file Interval_defs.hh.

template<typename Boundary, typename Info>

Boundary Parma_Polyhedra_Library::Interval< Boundary, Info >::upper_

private

Definition at line 768 of file Interval_defs.hh.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Related Functions

Detailed Description

template<typename Boundary, typename Info> class Parma_Polyhedra_Library::Interval< Boundary, Info >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename Boundary, typename Info>
class Parma_Polyhedra_Library::Interval< Boundary, Info >